package com.wicket.okrframework.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrcomponent.integration.FwCompOffStateClient;
import com.wicket.okrcomponent.integration.dto.QueryItemMatchResultToAnswerDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryItemMatchResultToAnswerDetailComRespDto;
import com.wicket.okrframework.base.service.*;
import com.wicket.okrframework.base.service.dto.req.*;
import com.wicket.okrframework.biz.service.*;
import com.wicket.okrframework.biz.service.dto.common.BaseBatchDto;
import com.wicket.okrframework.biz.service.dto.common.MergeInductionRecordDto;
import com.wicket.okrframework.biz.service.dto.req.*;
import com.wicket.okrframework.biz.service.dto.res.*;
import com.wicket.okrframework.biz.service.nb.NbBatch;
import com.wicket.okrframework.common.util.CommonFunctionHelper;
import com.wicket.okrframework.common.util.RedisUtil;
import com.wicket.okrframework.dal.po.mbg.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import com.wicket.okrframework.common.exception.Assert;
import com.wicket.okrframework.biz.service.dto.common.StaffingDto;

import java.util.concurrent.Callable;
import com.wicket.okrframework.common.exception.BizException;
import cn.hutool.core.collection.CollectionUtil;

import java.util.Collections;

import com.wicket.okrframework.biz.service.dto.common.NewInductionRecordDto;
import com.wicket.okrframework.biz.service.dto.common.OldInductionRecordDto;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
@Slf4j
public class BatchServiceImpl
        implements com.wicket.okrframework.biz.service.BatchService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MBatchService mBatchService;
    @Resource
    private MOrganizationService mOrganizationService;
    @Resource
    private MInductionRecordService mInductionRecordService;
    @Resource
    private MChangeColumnService mChangeColumnService;
    @Resource
    private MStaffingService mStaffingService;
    @Resource
    private MPrivacyDistributionService mPrivacyDistributionService;
    @Resource
    private MDeptPositionRelationshipService mDeptPositionRelationshipService;
    @Resource
    private MPositionService mPositionService;
    @Resource
    private MStaffingAccountService mStaffingAccountService;
    @Resource
    private NbBatch nbBatch;
    @Resource
    private FwCompConfSchemeClient fwCompConfSchemeClient;
    @Resource
    private OffStateService offStateService;
@Resource
  private ChangeColumnService changeColumnService;
@Resource
  private StaffingService staffingService;
@Resource
  private PowerService powerService;
@Resource
  private OrgPositionService orgPositionService;
@Resource
  private MStatusCheckItemService mStatusCheckItemService;
@Resource
  private MTypeDictionaryService mTypeDictionaryService;
@Resource
  private MDeptService mDeptService;
@Resource
  private OrgService orgService;
@Resource
  private InductionRecordService inductionRecordService;
@Resource
  private MemberService memberService;
//@Resource
 //private MCustomFields2Service mCustomFields2Service;
    // @Resource
    // private MSpecMethordTableService mSpecMethordTableService;
    // @Resource
    // private undefinedService undefinedService;



    /**
   * D1-1查询底层框架服务批次列表[264]
   * gen by moon at 10/2/2022, 2:58:19 AM
   */
  @Trace(operationName = "D1-1查询底层框架服务批次列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryBaseBatchListRespDto queryBaseBatchList(QueryBaseBatchListReqDto reqDto){
    
      
      List<Batch> listBatch_1 =new ArrayList<>();
//步骤0: 1-1-01查询底层框架服务批次列表 - queryBaseBatchList
     List<Batch> listBatch =new ArrayList<>();
    QueryBaseBatchListReq queryBaseBatchListReq=new QueryBaseBatchListReq();
  queryBaseBatchListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23612_1
queryBaseBatchListReq.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23613_1
if(reqDto!=null){
      queryBaseBatchListReq.setPurposeTypeCode(reqDto.getPurposeTypeCode());//SimpleFieldAssign//sourceId:3883_1
queryBaseBatchListReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:3884_1
queryBaseBatchListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:17424_1
queryBaseBatchListReq.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:19810_1
    }
  
    /*1-1-01查询底层框架服务批次列表[227]   */
    Assert.isNull(queryBaseBatchListReq.getPurposeTypeCode(),"D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchListReq.getAscriptionObjectId(),"D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchListReq.getSpaceId(),"D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-创建于空间ID不能为空",false);
Assert.isNull(queryBaseBatchListReq.getAppId(),"D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-创建于联盟应用ID不能为空",false);
      listBatch = mBatchService.queryBaseBatchList(queryBaseBatchListReq);
      

      listBatch_1 = listBatch;
    
QueryBaseBatchListRespDto retData = new QueryBaseBatchListRespDto();
  retData.setBaseBatchList(listBatch_1.stream().map(item -> BeanUtil.toBean(item, BaseBatchDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:3907_1
  

  
  
return retData;
  }

    /**
   * D1-1新增底层框架服务批次[242]
   * gen by moon at 8/10/2022, 3:21:29 AM
   */
  @Trace(operationName = "D1-1新增底层框架服务批次")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddBaseBatchRespDto addBaseBatch(AddBaseBatchReqDto reqDto){
    
      
      Batch batch_1 = null;
String string_1 = null;
//virtualUsage 查询是否有正在编辑的批次，避免重复  1583
      Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq.setSubjectLifeCycle("EDITING");//sourceId:3549_1_1583
if(reqDto!=null){
      queryBaseBatchDetailReq.setPurposeTypeCode(reqDto.getPurposeTypeCode());//sourceId:23717_1_1583
queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//sourceId:13588_1_1583
    }
  
    /*查询是否有正在编辑的批次，避免重复[44] 批次生命周期入参        正在编辑：EDITING
如果批次ID 存在，返回批次ID，批次ID 不存在，返回-1，返回-1才执行下一步虚拟用况  */
    Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(),"D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(),"D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(),"D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-主体生命周期不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getSpaceId(),"D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-创建于空间ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getAppId(),"D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-创建于联盟应用ID不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);
      
      batch_1 = batch;
if((ObjectUtil.isEmpty(batch))) {
        //if(查询是否有正在编辑的批次，避免重复.出参 等于空 )  1584
        
String string = null;
    Batch batch_2=new Batch();
  batch_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23641_1_1585
batch_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23642_1_1585
if(reqDto!=null){
      batch_2.setPurposeTypeCode(reqDto.getPurposeTypeCode());//sourceId:3459_1_1585
batch_2.setAscriptionObjectId(reqDto.getAscriptionObjectId());//sourceId:3460_1_1585
batch_2.setIsFirst(reqDto.getIsFirst());//sourceId:17396_1_1585
    }
  
    /*1-1-01新增底层框架服务批次[41]   */
    Assert.isNull(batch_2.getPurposeTypeCode(),"D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-用途类型编码不能为空",false);
Assert.isNull(batch_2.getAscriptionObjectId(),"D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-归属对象ID不能为空",false);
Assert.isNull(batch_2.getIsFirst(),"D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-是否首次批次不能为空",false);
Assert.isNull(batch_2.getSpaceId(),"D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-创建于空间ID不能为空",false);
Assert.isNull(batch_2.getAppId(),"D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-创建于联盟应用ID不能为空",false);
      string = mBatchService.addBaseBatch(batch_2);
      
      string_1 = string;
UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
    UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto=new UpdateCheckItemStatComReqDto();
  updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144788_1_8669
updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144789_1_8669
updateCheckItemStatComReqDto.setIsComplete("FALSE");//sourceId:144787_1_8669
if(reqDto!=null){
      updateCheckItemStatComReqDto.setEntityId(reqDto.getAscriptionObjectId());;//sourceId:144790_1_8669
    }
  
    /*D1-1修改检查项状态(公共)[947]   */
    Assert.isNull(updateCheckItemStatComReqDto,"D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto,"D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto,"D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto,"D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-是否已完成不能为空",false);
      updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);
      
      
      }
else{
       //else  8486
      
//processBranchName:正常结束 ,processBranchId:8487
        
    }
AddBaseBatchRespDto retData = new AddBaseBatchRespDto();
  if(batch_1!=null){
      retData.setBatchId(batch_1.getBatchId());//sourceId:56487_1
    }
if(string_1!=null){
      retData.setBatchId(string_1);//sourceId:56487_1
    }
  

  
  
return retData;
  }

    /**
   * D1-1查询底层框架服务批次详情[1805]
   * gen by moon at 10/2/2022, 12:45:38 AM
   */
  @Trace(operationName = "D1-1查询底层框架服务批次详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryBaseBatchDetailRespDto queryBaseBatchDetail(QueryBaseBatchDetailReqDto reqDto){
    
      
      Batch batch_1 =null;
//步骤0: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
     Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  if(reqDto!=null){
      queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:55140_1
queryBaseBatchDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:259682_1
    }
  
    /*1-1-01查询底层框架服务批次详情[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getBatchId(),"D1-1查询底层框架服务批次详情-1-1-01查询底层框架服务批次详情-批次ID不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);
      

      batch_1 = batch;
    
QueryBaseBatchDetailRespDto retData = new QueryBaseBatchDetailRespDto();
  if(batch_1!=null){
      retData.setBatchId(batch_1.getBatchId());//SimpleFieldAssign//sourceId:55142_1
retData.setIsFirst(batch_1.getIsFirst());//SimpleFieldAssign//sourceId:55143_1
retData.setSubjectLifeCycle(batch_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:55144_1
retData.setIsEditing(batch_1.getIsEditing());//SimpleFieldAssign//sourceId:55145_1
    }
  

  
  
return retData;
  }
/**
   * D1-1撤销修订组织架构底层批次自身处理(公共)[3741]
   * gen by moon at 10/1/2022, 11:48:42 PM
   */
  @Trace(operationName = "D1-1撤销修订组织架构底层批次自身处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UndoReviseOrgBaseBatchOwnHandleComRespDto undoReviseOrgBaseBatchOwnHandleCom(UndoReviseOrgBaseBatchOwnHandleComReqDto reqDto){
    
      
      //步骤0: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
     Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq.setIsNewbatch("TRUE");//sourceId:261586_1
queryBaseBatchDetailReq.setSubjectLifeCycle("EDITING");//sourceId:175863_1
if(reqDto!=null){
      queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175862_1
    }
  
    /*1-1-01查当前正在编辑底层框架服务批次[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getBatchId(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查当前正在编辑底层框架服务批次-批次ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getIsNewbatch(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查当前正在编辑底层框架服务批次-是否最新批次不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查当前正在编辑底层框架服务批次-主体生命周期不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);
      Assert.isTrue(batch== null||  batch.getBatchId() ==null,"返回值不能为空",false);
      
      
    
//步骤1: 1-1-01删除底层框架服务批次	 - deleteBaseBatch
     boolean bOOLEAN ;
    if(batch !=null){
          String string=new String();
  if(batch!=null){
      string=batch.getBatchId();;//SimpleFieldAssign//sourceId:175865_1
    }
  
    /*1-1-01删除当前正在编辑底层框架服务批次[43]   */
    Assert.isNull(string,"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01删除当前正在编辑底层框架服务批次-批次ID不能为空",false);
      bOOLEAN = mBatchService.deleteBaseBatch(string);
      
      
      
           }
    
//步骤2: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
     Batch batch_2 = null;
    if(batch !=null){
          QueryBaseBatchDetailReq queryBaseBatchDetailReq_1=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq_1.setPurposeTypeCode("ORG");//sourceId:284994_1
queryBaseBatchDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285000_1
if(batch!=null){
      queryBaseBatchDetailReq_1.setAscriptionObjectId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:284995_1
    }
  
    /*1-1-01查询上一批次[44]   */
    Assert.isNull(queryBaseBatchDetailReq_1.getAscriptionObjectId(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查询上一批次-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq_1.getPurposeTypeCode(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查询上一批次-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchDetailReq_1.getSubjectLifeCycle(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查询上一批次-主体生命周期不能为空",false);
      batch_2 = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq_1);
      Assert.isTrue(batch_2== null||  batch_2.getBatchId() ==null,"返回值不能为空",false);
      
      
           }
    
//步骤3: 1-1-01修改底层框架服务批次	 - updateBaseBatch
     boolean bOOLEAN_1 ;
    if(batch_2 !=null){
          Batch batch_4=new Batch();
  batch_4.setIsNewbatch("TRUE");//sourceId:285074_1
batch_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285040_1
batch_4.setIsArchive("FALSE");//sourceId:285047_1
batch_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:285044_1
batch_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:285045_1
if(batch_2!=null){
      batch_4.setBatchId(batch_2.getBatchId());//SimpleFieldAssign//sourceId:285035_1
    }
  
    /*1-1-01恢复上一批次生命周期状态[42]   */
    Assert.isNull(batch_4.getBatchId(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-批次ID不能为空",false);
Assert.isNull(batch_4.getIsNewbatch(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-是否最新批次不能为空",false);
Assert.isNull(batch_4.getSubjectLifeCycle(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-主体生命周期不能为空",false);
Assert.isNull(batch_4.getIsArchive(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-是否存档不能为空",false);
Assert.isNull(batch_4.getOperationInductionId(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-操作人就职记录ID不能为空",false);
Assert.isNull(batch_4.getOperateTime(),"D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-操作时间不能为空",false);
      bOOLEAN_1 = mBatchService.updateBaseBatch(batch_4);
      
      
      
           }
    
UndoReviseOrgBaseBatchOwnHandleComRespDto retData = new UndoReviseOrgBaseBatchOwnHandleComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1发布组织架构底层批次自身处理(公共)[3740]
   * gen by moon at 10/1/2022, 11:48:54 PM
   */
  @Trace(operationName = "D1-1发布组织架构底层批次自身处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReleaseOrgBaseBatchOwnHandleComRespDto releaseOrgBaseBatchOwnHandleCom(ReleaseOrgBaseBatchOwnHandleComReqDto reqDto){
    
      
      //步骤0: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
     Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:175804_1
if(reqDto!=null){
      queryBaseBatchDetailReq.setPurposeTypeCode(reqDto.getPurposeTypeCode());//SimpleFieldAssign//sourceId:175802_1
queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:175803_1
    }
  
    /*1-1-01查上一底层框架批次（用于历史存档）[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01查上一底层框架批次（用于历史存档）-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01查上一底层框架批次（用于历史存档）-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01查上一底层框架批次（用于历史存档）-主体生命周期不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);
      
      
      
    
//步骤1: 1-1-01修改底层框架服务批次	 - updateBaseBatch
     boolean bOOLEAN ;
    if(batch !=null){
          Batch batch_2=new Batch();
  batch_2.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175790_1
batch_2.setSubjectLifeCycle("ARCHIVING");//sourceId:175791_1
batch_2.setIsNewbatch("FALSE");//sourceId:246853_1
batch_2.setIsArchive("TRUE");//sourceId:175792_1
batch_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175812_1
batch_2.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175813_1
batch_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175814_1
batch_2.setArchiveTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175815_1
if(batch!=null){
      batch_2.setBatchId(batch.getBatchId());//SimpleFieldAssign//sourceId:175786_1
    }
  
    /*1-1-01修改上一底层框架批次历史存档[42]   */
    Assert.isNull(batch_2.getBatchId(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-批次ID不能为空",false);
Assert.isNull(batch_2.getBatchEndTime(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-批次结束时间不能为空",false);
Assert.isNull(batch_2.getSubjectLifeCycle(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-主体生命周期不能为空",false);
Assert.isNull(batch_2.getIsNewbatch(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-是否最新批次不能为空",false);
Assert.isNull(batch_2.getIsArchive(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-是否存档不能为空",false);
Assert.isNull(batch_2.getOperationInductionId(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-操作人就职记录ID不能为空",false);
Assert.isNull(batch_2.getArchiveInductionId(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-存档人就职记录ID不能为空",false);
Assert.isNull(batch_2.getOperateTime(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-操作时间不能为空",false);
Assert.isNull(batch_2.getArchiveTime(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-存档时间不能为空",false);
      bOOLEAN = mBatchService.updateBaseBatch(batch_2);
      
      
      
           }
    
//步骤2: 1-1-01修改底层框架服务批次	 - updateBaseBatch
     boolean bOOLEAN_1 ;
    Batch batch_3=new Batch();
  batch_3.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175797_1
batch_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:175799_1
batch_3.setIsEditing("FALSE");//sourceId:175801_1
batch_3.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175808_1
batch_3.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175809_1
batch_3.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175810_1
batch_3.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175811_1
if(reqDto!=null){
      batch_3.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175794_1
    }
  
    /*1-1-01修改当前底层框架服务批次为当前有效[42]   */
    Assert.isNull(batch_3.getBatchId(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-批次ID不能为空",false);
Assert.isNull(batch_3.getBatchStartTime(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-批次开始时间不能为空",false);
Assert.isNull(batch_3.getSubjectLifeCycle(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-主体生命周期不能为空",false);
Assert.isNull(batch_3.getIsEditing(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-是否未来不能为空",false);
Assert.isNull(batch_3.getOperationInductionId(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-操作人就职记录ID不能为空",false);
Assert.isNull(batch_3.getReleaseInductionId(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-发布人就职记录ID不能为空",false);
Assert.isNull(batch_3.getOperateTime(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-操作时间不能为空",false);
Assert.isNull(batch_3.getReleaseTime(),"D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-发布时间不能为空",false);
      bOOLEAN_1 = mBatchService.updateBaseBatch(batch_3);
      
      
      
    
ReleaseOrgBaseBatchOwnHandleComRespDto retData = new ReleaseOrgBaseBatchOwnHandleComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1撤销组织架构成员基础批次处理(公共)[3727]
   * gen by moon at 10/1/2022, 11:53:29 PM
   */
  @Trace(operationName = "D1-1撤销组织架构成员基础批次处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UndoOrgBaseBatchProcessingComRespDto undoOrgBaseBatchProcessingCom(UndoOrgBaseBatchProcessingComReqDto reqDto){
    
      
      //步骤0: D1-1撤销修订组织架构底层批次自身处理(公共) - undoReviseOrgBaseBatchOwnHandleCom
     UndoReviseOrgBaseBatchOwnHandleComRespDto undoReviseOrgBaseBatchOwnHandleComRespDto = null;
    UndoReviseOrgBaseBatchOwnHandleComReqDto undoReviseOrgBaseBatchOwnHandleComReqDto=new UndoReviseOrgBaseBatchOwnHandleComReqDto();
  if(reqDto!=null){
      undoReviseOrgBaseBatchOwnHandleComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175875_1
    }
  
    /*D1-1撤销修订组织架构底层批次自身处理(公共)[3741]   */
    Assert.isNull(undoReviseOrgBaseBatchOwnHandleComReqDto.getBatchId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构底层批次自身处理(公共)-批次ID不能为空",false);
      undoReviseOrgBaseBatchOwnHandleComRespDto = undoReviseOrgBaseBatchOwnHandleCom(undoReviseOrgBaseBatchOwnHandleComReqDto);
      
      
      
    
//步骤1: D1-1撤销修订组织架构批次处理变更字段(公共) - undoReviseOrgBatchHandleChangeColCom
     UndoReviseOrgBatchHandleChangeColComRespDto undoReviseOrgBatchHandleChangeColComRespDto = null;
    UndoReviseOrgBatchHandleChangeColComReqDto undoReviseOrgBatchHandleChangeColComReqDto=new UndoReviseOrgBatchHandleChangeColComReqDto();
  undoReviseOrgBatchHandleChangeColComReqDto.setObjectTypeCode("OMS_ORG_ORGANIZATION");//sourceId:176408_1
if(reqDto!=null){
      undoReviseOrgBatchHandleChangeColComReqDto.setObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176409_1
undoReviseOrgBatchHandleChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176410_1
    }
  
    /*D1-1撤销修订组织架构批次处理变更字段(公共)[3743]   */
    Assert.isNull(undoReviseOrgBatchHandleChangeColComReqDto.getObjectTypeCode(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构批次处理变更字段(公共)-归属对象类型编码不能为空",false);
Assert.isNull(undoReviseOrgBatchHandleChangeColComReqDto.getObjectId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构批次处理变更字段(公共)-归属对象内容ID不能为空",false);
Assert.isNull(undoReviseOrgBatchHandleChangeColComReqDto.getBatchId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构批次处理变更字段(公共)-批次ID不能为空",false);
      undoReviseOrgBatchHandleChangeColComRespDto = changeColumnService.undoReviseOrgBatchHandleChangeColCom(undoReviseOrgBatchHandleChangeColComReqDto);
      
      
      
    
//步骤2: D1-1修改检查项状态(公共) - updateCheckItemStatCom
     UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
    UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto=new UpdateCheckItemStatComReqDto();
  updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:194302_1
updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:194303_1
updateCheckItemStatComReqDto.setIsComplete("TRUE");//sourceId:194301_1
if(reqDto!=null){
      updateCheckItemStatComReqDto.setEntityId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:194304_1
    }
  
    /*D1-1修改组织成员管理检查项状态为完成[947]   */
    Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getEntityId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-是否已完成不能为空",false);
      updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);
      
      
      
    
//步骤3: D1-1修改检查项状态(公共) - updateCheckItemStatCom
     UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto_1 = null;
    UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto_1=new UpdateCheckItemStatComReqDto();
  updateCheckItemStatComReqDto_1.setCheckItemCode("ORG_MGT_CHECK");//CUSTOM_CONVENTION//sourceId:284990_1
updateCheckItemStatComReqDto_1.setObjectTypeCode("ORG_CHECK");//sourceId:284991_1
updateCheckItemStatComReqDto_1.setIsComplete("TRUE");//sourceId:284989_1
if(reqDto!=null){
      updateCheckItemStatComReqDto_1.setEntityId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:284992_1
    }
  
    /*D1-1修改组织管理检查项状态已完成[947]   */
    Assert.isNull(updateCheckItemStatComReqDto_1.getCheckItemCode(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto_1.getObjectTypeCode(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto_1.getEntityId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto_1.getIsComplete(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-是否已完成不能为空",false);
      updateCheckItemStatComRespDto_1 = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto_1);
      
      
      
    
//步骤4: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(80L);//CUSTOM_CONVENTION//sourceId:175490_1
refreshMemberBatchProgressComReqDto.setBatchHandleStep("2");//CUSTOM_CONVENTION//sourceId:175491_1
refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:175492_1
refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318748_1
refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318749_1
refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318750_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279738_1
    }
  
    /*D1-3更新组织架构成员批次处理进度80(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(),"D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto);
      
      
      
    
UndoOrgBaseBatchProcessingComRespDto retData = new UndoOrgBaseBatchProcessingComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1发布组织架构成员基础批次处理(公共)[3726]
   * gen by moon at 9/20/2023, 11:29:37 PM
   */
  @Trace(operationName = "D1-1发布组织架构成员基础批次处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReleaseOrgBaseBatchProcessingComRespDto releaseOrgBaseBatchProcessingCom(ReleaseOrgBaseBatchProcessingComReqDto reqDto){
    
      
      //步骤0: D1-1发布组织架构底层批次自身处理(公共) - releaseOrgBaseBatchOwnHandleCom
     ReleaseOrgBaseBatchOwnHandleComRespDto releaseOrgBaseBatchOwnHandleComRespDto = null;
    ReleaseOrgBaseBatchOwnHandleComReqDto releaseOrgBaseBatchOwnHandleComReqDto=new ReleaseOrgBaseBatchOwnHandleComReqDto();
  releaseOrgBaseBatchOwnHandleComReqDto.setPurposeTypeCode("ORG");//sourceId:175817_1
if(reqDto!=null){
      releaseOrgBaseBatchOwnHandleComReqDto.setAscriptionObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:175818_1
releaseOrgBaseBatchOwnHandleComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175819_1
    }
  
    /*D1-1发布组织架构底层批次自身处理(公共)[3740]   */
    Assert.isNull(releaseOrgBaseBatchOwnHandleComReqDto.getPurposeTypeCode(),"D1-1发布组织架构成员基础批次处理(公共)-D1-1发布组织架构底层批次自身处理(公共)-用途类型编码不能为空",false);
Assert.isNull(releaseOrgBaseBatchOwnHandleComReqDto.getAscriptionObjectId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-1发布组织架构底层批次自身处理(公共)-归属对象ID不能为空",false);
Assert.isNull(releaseOrgBaseBatchOwnHandleComReqDto.getBatchId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-1发布组织架构底层批次自身处理(公共)-批次ID不能为空",false);
      releaseOrgBaseBatchOwnHandleComRespDto = releaseOrgBaseBatchOwnHandleCom(releaseOrgBaseBatchOwnHandleComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
//步骤1: D1-1更新批次处理组织架构变更字段(公共) - refreshBatchProcessingOrgChangeColCom
     RefreshBatchProcessingOrgChangeColComRespDto refreshBatchProcessingOrgChangeColComRespDto = null;
    RefreshBatchProcessingOrgChangeColComReqDto refreshBatchProcessingOrgChangeColComReqDto=new RefreshBatchProcessingOrgChangeColComReqDto();
  refreshBatchProcessingOrgChangeColComReqDto.setObjectTypeCode("OMS_ORG_ORGANIZATION");//sourceId:306223_1
if(reqDto!=null){
      refreshBatchProcessingOrgChangeColComReqDto.setObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:306224_1
refreshBatchProcessingOrgChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:306225_1
    }
  
    /*D1-1更新批次处理组织架构变更字段(公共)[3742]   */
    Assert.isNull(refreshBatchProcessingOrgChangeColComReqDto.getObjectTypeCode(),"D1-1发布组织架构成员基础批次处理(公共)-D1-1更新批次处理组织架构变更字段(公共)-归属对象类型编码不能为空",false);
Assert.isNull(refreshBatchProcessingOrgChangeColComReqDto.getObjectId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-1更新批次处理组织架构变更字段(公共)-归属对象内容ID不能为空",false);
Assert.isNull(refreshBatchProcessingOrgChangeColComReqDto.getBatchId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-1更新批次处理组织架构变更字段(公共)-批次ID不能为空",false);
      refreshBatchProcessingOrgChangeColComRespDto = changeColumnService.refreshBatchProcessingOrgChangeColCom(refreshBatchProcessingOrgChangeColComReqDto)/*vcase invoke isSameApp*/;
      
      
      
    
//步骤2: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(80));//CUSTOM_CONVENTION//sourceId:264452_1
refreshMemberBatchProgressComReqDto.setBatchHandleStep("2");//CUSTOM_CONVENTION//sourceId:175471_1
refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:175472_1
refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318745_1
refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318746_1
refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318747_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279718_1
    }
  
    /*D1-3更新组织架构成员批次处理进度80(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(),"D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(),"D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(),"D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(),"D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
ReleaseOrgBaseBatchProcessingComRespDto retData = new ReleaseOrgBaseBatchProcessingComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-3撤销就职记录相关批次处理(公共)[3725]
   * gen by moon at 10/16/2022, 1:54:11 AM
   */
  @Trace(operationName = "D1-3撤销就职记录相关批次处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UndoInductionRecordBatchProcessingComRespDto undoInductionRecordBatchProcessingCom(UndoInductionRecordBatchProcessingComReqDto reqDto){
    
      
      //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
     List<InductionRecord> listInductionRecord =new ArrayList<>();
    QueryInductionRecordListReq queryInductionRecordListReq=new QueryInductionRecordListReq();
  queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:176575_1
queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:176576_1
if(reqDto!=null){
      queryInductionRecordListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176573_1
queryInductionRecordListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176574_1
    }
  
    /*1-3-13查本次新增就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq.getOrganizationId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq.getBatchId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次ID不能为空",false);
Assert.isNull(queryInductionRecordListReq.getUpdateStatus(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次下更新状态不能为空",false);
Assert.isNull(queryInductionRecordListReq.getSpaceId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-创建于空间ID不能为空",false);
      listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);
      
      
      
    
//步骤1: 1-3-13批量删除就职记录 - batchDeleteInductionRecord
     boolean bOOLEAN ;
    if(listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)&& listInductionRecord.size()>0 ){
          List<String> listString=new ArrayList<>();
  listString = listInductionRecord.stream().map(item->item.getInductionRecordId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:176480_1
  
    /*1-3-13批量删除就职记录[1685]   */
    
      bOOLEAN = mInductionRecordService.batchDeleteInductionRecord(listString);
      
      
      
           }
    
//步骤2: 1-3-14批量查询编制 - batchQueryStaffing
     List<Staffing> listStaffing =new ArrayList<>();
    if(listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)&& listInductionRecord.size()>0 ){
          BatchQueryStaffingReq batchQueryStaffingReq=new BatchQueryStaffingReq();
  batchQueryStaffingReq.setStaffingList(listInductionRecord.stream().map(item->item.getStaffingId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:380560_1
batchQueryStaffingReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:380561_1
  
    /*1-3-14批量查询编制[3767]   */
    Assert.isNull(batchQueryStaffingReq.getSubjectLifeCycle(),"D1-3撤销就职记录相关批次处理(公共)-1-3-14批量查询编制-主体生命周期不能为空",false);
      listStaffing = mStaffingService.batchQueryStaffing(batchQueryStaffingReq);
      
      
      
           }
    
//步骤3: 1-3-14批量修改编制 - batchUpdateStaffing
     boolean bOOLEAN_1 ;
    if(listStaffing !=null&& !CollectionUtil.isEmpty(listStaffing)&& listStaffing.size()>0 ){
          List<Staffing> listStaffing_2=new ArrayList<>();
  if(listStaffing!= null&& !CollectionUtil.isEmpty(listStaffing)&&  listStaffing !=null&& !CollectionUtil.isEmpty(listStaffing)){
      listStaffing_2 = listStaffing.stream().map(item -> {
        Staffing elm =BeanUtil.toBean(item, Staffing.class);
        elm.setInductionState("FALSE");
elm.setTempLock("FALSE");
        
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:176570_1
    }
  
    /*1-3-14批量释放编制（有编制的）[931]   */
    
      bOOLEAN_1 = mStaffingService.batchUpdateStaffing(listStaffing_2);
      
      
      
           }
    
//步骤4: 1-3-13查询就职记录列表 - queryInductionRecordList
     List<InductionRecord> listInductionRecord_2 =new ArrayList<>();
    QueryInductionRecordListReq queryInductionRecordListReq_1=new QueryInductionRecordListReq();
  queryInductionRecordListReq_1.setUpdateStatus("ARCHIVE");//sourceId:176604_1
queryInductionRecordListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:176603_1
if(reqDto!=null){
      queryInductionRecordListReq_1.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176602_1
queryInductionRecordListReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176601_1
    }
  
    /*1-3-13查本次存档就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_1.getBatchId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-批次ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_1.getOrganizationId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_1.getUpdateStatus(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-批次下更新状态不能为空",false);
Assert.isNull(queryInductionRecordListReq_1.getSpaceId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-创建于空间ID不能为空",false);
      listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);
      
      
      
    
//步骤5: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
     boolean bOOLEAN_2 ;
    if(listInductionRecord_2 !=null&& !CollectionUtil.isEmpty(listInductionRecord_2)&& listInductionRecord_2.size()>0 ){
          List<InductionRecord> listInductionRecord_4=new ArrayList<>();
  if(listInductionRecord_2!= null&& !CollectionUtil.isEmpty(listInductionRecord_2)&&  listInductionRecord_2 !=null&& !CollectionUtil.isEmpty(listInductionRecord_2)){
      listInductionRecord_4 = listInductionRecord_2.stream().map(item -> {
        InductionRecord elm =BeanUtil.toBean(item, InductionRecord.class);
        elm.setArchivngType("NOT_ARCHIVE");
elm.setIsUpdate("FALSE");
elm.setUpdateStatus("UNCHANGED");
        
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:176606_1
    }
  
    /*1-3-13批量改就职记录为未存档[1647]   */
    
      bOOLEAN_2 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_4);
      
      
      
           }
    
//步骤6: 1-3-13查询就职记录列表 - queryInductionRecordList
     List<InductionRecord> listInductionRecord_5 =new ArrayList<>();
    QueryInductionRecordListReq queryInductionRecordListReq_2=new QueryInductionRecordListReq();
  queryInductionRecordListReq_2.setUpdateStatus("REVISION");//sourceId:176613_1
queryInductionRecordListReq_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:176614_1
if(reqDto!=null){
      queryInductionRecordListReq_2.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176611_1
queryInductionRecordListReq_2.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176612_1
    }
  
    /*1-3-13查本次修订就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_2.getOrganizationId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_2.getBatchId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-批次ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_2.getUpdateStatus(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-批次下更新状态不能为空",false);
Assert.isNull(queryInductionRecordListReq_2.getSpaceId(),"D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-创建于空间ID不能为空",false);
      listInductionRecord_5 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2);
      
      
      
    
//步骤7: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
     boolean bOOLEAN_3 ;
    if(listInductionRecord_5 !=null&& !CollectionUtil.isEmpty(listInductionRecord_5)&& listInductionRecord_5.size()>0 ){
          List<InductionRecord> listInductionRecord_7=new ArrayList<>();
  if(listInductionRecord_5!= null&& !CollectionUtil.isEmpty(listInductionRecord_5)&&  listInductionRecord_5 !=null&& !CollectionUtil.isEmpty(listInductionRecord_5)){
      listInductionRecord_7 = listInductionRecord_5.stream().map(item -> {
        InductionRecord elm =BeanUtil.toBean(item, InductionRecord.class);
        elm.setIsUpdate("FALSE");
elm.setUpdateStatus("UNCHANGED");
        
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:176616_1
    }
  
    /*1-3-13批量改就职记录（重置本次修订）[1647]   */
    
      bOOLEAN_3 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_7);
      
      
      
           }
    
//步骤8: M-Redis批量清空用户信息（特殊方法） - batchClearUserInfoFromRedis
     //ModelCode: batchClearUserInfoFromRedis
        BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes = null;
    if(listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)&& listInductionRecord.size()>0 ){
          BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq=new BatchClearUserInfoFromRedisReqDto();
  batchClearUserInfoFromRedisReq.setBeginMemberList(listInductionRecord.stream().map(item->item.getOriginalRoleMemberId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:215633_1
  
    /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */
    
      batchClearUserInfoFromRedisRes = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq);
      
      
      
           }
    
//步骤9: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(20));//CUSTOM_CONVENTION//sourceId:284704_1
refreshMemberBatchProgressComReqDto.setBatchHandleStep("1");//CUSTOM_CONVENTION//sourceId:284705_1
refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:284706_1
refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318742_1
refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318743_1
refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318744_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:284709_1
    }
  
    /*D1-3更新组织架构成员批次处理进度20(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(),"D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(),"D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(),"D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(),"D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(),"D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(),"D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(),"D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto);
      
      
      
    
UndoInductionRecordBatchProcessingComRespDto retData = new UndoInductionRecordBatchProcessingComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-3发布就职记录相关批次处理(公共)[3724]
   * gen by moon at 12/25/2023, 1:30:44 AM
   */
  @Trace(operationName = "D1-3发布就职记录相关批次处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReleaseInductionRecordBatchProcessingComRespDto releaseInductionRecordBatchProcessingCom(ReleaseInductionRecordBatchProcessingComReqDto reqDto){
    

      //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
     List<InductionRecord> listInductionRecord =new ArrayList<>();
    QueryInductionRecordListReq queryInductionRecordListReq=new QueryInductionRecordListReq();
  queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:177081_1
queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:177082_1
if(reqDto!=null){
      queryInductionRecordListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:177079_1
queryInductionRecordListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:177080_1
    }
  
    /*1-3-13查本次新增就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq.getOrganizationId(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq.getBatchId(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次ID不能为空",false);
Assert.isNull(queryInductionRecordListReq.getUpdateStatus(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次下更新状态不能为空",false);
Assert.isNull(queryInductionRecordListReq.getSpaceId(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-创建于空间ID不能为空",false);
      listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      

    
//步骤1: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
     boolean bOOLEAN ;
    if(listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)&& listInductionRecord.size()>0 ){
          List<InductionRecord> listInductionRecord_2=new ArrayList<>();
  if(listInductionRecord!= null&& !CollectionUtil.isEmpty(listInductionRecord)&&  listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)){
  listInductionRecord_2 = listInductionRecord.stream().map(item -> {
        InductionRecord elm =BeanUtil.toBean(item, InductionRecord.class);
        elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
elm.setSubjectLifeCycle("CURRENTLY_VALID");
elm.setIsEditing("FALSE");
elm.setIsUpdate("FALSE");
elm.setUpdateStatus("UNCHANGED");

        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:177086_1
    }

    /*1-3-13批量改就职记录为当前有效[1647]   */
    
      bOOLEAN = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
//步骤2: D1-执行批次新增编制处理(公共) - implementBatchStaffingCreateCom
     ImplementBatchStaffingCreateComRespDto implementBatchStaffingCreateComRespDto = null;
    if(listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)&& listInductionRecord.size()>0 ){
          ImplementBatchStaffingCreateComReqDto implementBatchStaffingCreateComReqDto=new ImplementBatchStaffingCreateComReqDto();
  if(listInductionRecord!= null&& !CollectionUtil.isEmpty(listInductionRecord)&&  listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)){
  implementBatchStaffingCreateComReqDto.setStaffingList(listInductionRecord.stream().map(item->item.getStaffingId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:259807_1
    }

    /*D1-执行批次新增编制处理(公共)[4204]   */
    
      implementBatchStaffingCreateComRespDto = staffingService.implementBatchStaffingCreateCom(implementBatchStaffingCreateComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤3: 1-3-13查询就职记录列表 - queryInductionRecordList
     List<InductionRecord> listInductionRecord_3 =new ArrayList<>();
    QueryInductionRecordListReq queryInductionRecordListReq_1=new QueryInductionRecordListReq();
  queryInductionRecordListReq_1.setUpdateStatus("ARCHIVE");//sourceId:177110_1
queryInductionRecordListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:177111_1
if(reqDto!=null){
      queryInductionRecordListReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:177108_1
    }
  
    /*1-3-13查本次存档就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_1.getOrganizationId(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_1.getUpdateStatus(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-批次下更新状态不能为空",false);
Assert.isNull(queryInductionRecordListReq_1.getSpaceId(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-创建于空间ID不能为空",false);
      listInductionRecord_3 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1)/*vcase invoke 本地 method 方法调用;*/;
      
      

    
//步骤4: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
     boolean bOOLEAN_1 ;
    if(listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)&& listInductionRecord_3.size()>0 ){
          List<InductionRecord> listInductionRecord_5=new ArrayList<>();
  if(listInductionRecord_3!= null&& !CollectionUtil.isEmpty(listInductionRecord_3)&&  listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)){
  listInductionRecord_5 = listInductionRecord_3.stream().map(item -> {
        InductionRecord elm =BeanUtil.toBean(item, InductionRecord.class);
        elm.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
elm.setSubjectLifeCycle("ARCHIVING");
elm.setIsArchive("TRUE");
elm.setArchivngType("ARCHIVED");
elm.setIsUpdate("FALSE");
elm.setUpdateStatus("ARCHIVE");

        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:177115_1
    }

    /*1-3-13批量改就职记录为历史存档[1647]   */
    
      bOOLEAN_1 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_5)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
//步骤5: D1-执行批次存档编制处理(公共) - implementBatchStaffingArchiveCom
     ImplementBatchStaffingArchiveComRespDto implementBatchStaffingArchiveComRespDto = null;
    if(listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)&& listInductionRecord_3.size()>0 ){
          ImplementBatchStaffingArchiveComReqDto implementBatchStaffingArchiveComReqDto=new ImplementBatchStaffingArchiveComReqDto();
  if(listInductionRecord_3!= null&& !CollectionUtil.isEmpty(listInductionRecord_3)&&  listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)){
  implementBatchStaffingArchiveComReqDto.setStaffingList(listInductionRecord_3.stream().map(item->item.getStaffingId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:259814_1
    }

    /*D1-执行批次存档编制处理(公共)[4205]   */
    
      implementBatchStaffingArchiveComRespDto = staffingService.implementBatchStaffingArchiveCom(implementBatchStaffingArchiveComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤6: D1-2执行权限更新状态(公共) - implementPowerUpdateStatusCom
     ImplementPowerUpdateStatusComRespDto implementPowerUpdateStatusComRespDto = null;
    if(listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)&& listInductionRecord_3.size()>0 ){
          ImplementPowerUpdateStatusComReqDto implementPowerUpdateStatusComReqDto=new ImplementPowerUpdateStatusComReqDto();
  implementPowerUpdateStatusComReqDto.setTypeCode("PERSONAL_DEPARTMENT");//sourceId:178271_1
if(listInductionRecord_3!= null&& !CollectionUtil.isEmpty(listInductionRecord_3)&&  listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)){
  implementPowerUpdateStatusComReqDto.setTributPowerList(listInductionRecord_3.stream().map(item->item.getInductionRecordId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:178270_1
    }
  
    /*D1-2执行权限更新状态(公共)[3762]   */
    Assert.isNull(implementPowerUpdateStatusComReqDto.getTypeCode(),"D1-3发布就职记录相关批次处理(公共)-D1-2执行权限更新状态(公共)-分配对象类型编码不能为空",false);
      implementPowerUpdateStatusComRespDto = powerService.implementPowerUpdateStatusCom(implementPowerUpdateStatusComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤7: 1-3-13查询就职记录列表 - queryInductionRecordList
     List<InductionRecord> listInductionRecord_6 =new ArrayList<>();
    QueryInductionRecordListReq queryInductionRecordListReq_2=new QueryInductionRecordListReq();
  queryInductionRecordListReq_2.setUpdateStatus("REVISION");//sourceId:177118_1
queryInductionRecordListReq_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:177119_1
if(reqDto!=null){
      queryInductionRecordListReq_2.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:177116_1
    }
  
    /*1-3-13查本次修订就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_2.getOrganizationId(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_2.getUpdateStatus(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-批次下更新状态不能为空",false);
Assert.isNull(queryInductionRecordListReq_2.getSpaceId(),"D1-3发布就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-创建于空间ID不能为空",false);
      listInductionRecord_6 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤8: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
     boolean bOOLEAN_2 ;
    if(listInductionRecord_6 !=null&& !CollectionUtil.isEmpty(listInductionRecord_6)&& listInductionRecord_6.size()>0 ){
          List<InductionRecord> listInductionRecord_8=new ArrayList<>();
  if(listInductionRecord_6!= null&& !CollectionUtil.isEmpty(listInductionRecord_6)&&  listInductionRecord_6 !=null&& !CollectionUtil.isEmpty(listInductionRecord_6)){
  listInductionRecord_8 = listInductionRecord_6.stream().map(item -> {
        InductionRecord elm =BeanUtil.toBean(item, InductionRecord.class);
        elm.setIsUpdate("FALSE");
elm.setUpdateStatus("UNCHANGED");

        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:177121_1
    }

    /*1-3-13批量改就职记录（重置本次修订）[1647]   */
    
      bOOLEAN_2 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_8)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
//步骤9: D1执行批次发布部门职务处理(公共) - implementBatchFileDeptPositionHandleCom
     ImplementBatchFileDeptPositionHandleComRespDto implementBatchFileDeptPositionHandleComRespDto = null;
    ImplementBatchFileDeptPositionHandleComReqDto implementBatchFileDeptPositionHandleComReqDto=new ImplementBatchFileDeptPositionHandleComReqDto();
  if(reqDto!=null){
      implementBatchFileDeptPositionHandleComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:178787_1
    }
  
    /*D1执行批次发布部门职务处理(公共)[3765]   */
    Assert.isNull(implementBatchFileDeptPositionHandleComReqDto.getOrganizationId(),"D1-3发布就职记录相关批次处理(公共)-D1执行批次发布部门职务处理(公共)-组织ID不能为空",false);
      implementBatchFileDeptPositionHandleComRespDto = orgPositionService.implementBatchFileDeptPositionHandleCom(implementBatchFileDeptPositionHandleComReqDto)/*vcase invoke isSameApp*/;
      
      
      
    
//步骤10: M-Redis批量清空用户信息（特殊方法） - batchClearUserInfoFromRedis
     //ModelCode: batchClearUserInfoFromRedis
        BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes = null;
    if(listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)&& listInductionRecord_3.size()>0 ){
          BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq=new BatchClearUserInfoFromRedisReqDto();
  if(listInductionRecord_3!= null&& !CollectionUtil.isEmpty(listInductionRecord_3)&&  listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)){
  batchClearUserInfoFromRedisReq.setBeginMemberList(listInductionRecord_3.stream().map(item->item.getOriginalRoleMemberId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:178273_1
    }

    /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */
    
      batchClearUserInfoFromRedisRes = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq);
      
      
      
           }
    
//步骤11: D1执行循环部门群成员通道关系处理(公共) - implementLoopDeptGroupMemberChannelExitProcessCom
     ImplementLoopDeptGroupMemberChannelExitProcessComRespDto implementLoopDeptGroupMemberChannelExitProcessComRespDto = null;
    if(listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)&& listInductionRecord.size()>0 ){
          ImplementLoopDeptGroupMemberChannelExitProcessComReqDto implementLoopDeptGroupMemberChannelExitProcessComReqDto=new ImplementLoopDeptGroupMemberChannelExitProcessComReqDto();
  implementLoopDeptGroupMemberChannelExitProcessComReqDto.setMessageLocationCode("WORK_CIRCLE");//CUSTOM_CONVENTION//sourceId:1443282_1
implementLoopDeptGroupMemberChannelExitProcessComReqDto.setBorcScene("TOB_SCENE");//sourceId:1443283_1
if(listInductionRecord!= null&& !CollectionUtil.isEmpty(listInductionRecord)&&  listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)){
      implementLoopDeptGroupMemberChannelExitProcessComReqDto.setNewInductionRecordList(listInductionRecord.stream().map(item -> BeanUtil.toBean(item, NewInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443280_1
    }
if(listInductionRecord_3!= null&& !CollectionUtil.isEmpty(listInductionRecord_3)&&  listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)){
      implementLoopDeptGroupMemberChannelExitProcessComReqDto.setOldInductionRecordList(listInductionRecord_3.stream().map(item -> BeanUtil.toBean(item, OldInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443281_1
    }

    /*D1执行循环部门群成员通道关系处理(公共)[8198]   */
    Assert.isNull(implementLoopDeptGroupMemberChannelExitProcessComReqDto.getMessageLocationCode(),"D1-3发布就职记录相关批次处理(公共)-D1执行循环部门群成员通道关系处理(公共)-消息位置标识不能为空",false);
Assert.isNull(implementLoopDeptGroupMemberChannelExitProcessComReqDto.getBorcScene(),"D1-3发布就职记录相关批次处理(公共)-D1执行循环部门群成员通道关系处理(公共)-toB或toC场景不能为空",false);
      implementLoopDeptGroupMemberChannelExitProcessComRespDto = memberService.implementLoopDeptGroupMemberChannelExitProcessCom(implementLoopDeptGroupMemberChannelExitProcessComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤12: D1执行组织群成员通道关系处理(公共) - implementOrgGroupMemberChannelExitProcessCom
     ImplementOrgGroupMemberChannelExitProcessComRespDto implementOrgGroupMemberChannelExitProcessComRespDto = null;
    if(listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)&& listInductionRecord.size()>0 ){
          ImplementOrgGroupMemberChannelExitProcessComReqDto implementOrgGroupMemberChannelExitProcessComReqDto=new ImplementOrgGroupMemberChannelExitProcessComReqDto();
  implementOrgGroupMemberChannelExitProcessComReqDto.setMessageLocationCode("WORK_CIRCLE");//CUSTOM_CONVENTION//sourceId:1443337_1
implementOrgGroupMemberChannelExitProcessComReqDto.setBorcScene("TOB_SCENE");//sourceId:1443338_1
if(listInductionRecord!= null&& !CollectionUtil.isEmpty(listInductionRecord)&&  listInductionRecord !=null&& !CollectionUtil.isEmpty(listInductionRecord)){
      implementOrgGroupMemberChannelExitProcessComReqDto.setNewInductionRecordList(listInductionRecord.stream().map(item -> BeanUtil.toBean(item, NewInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443335_1
    }
if(listInductionRecord_3!= null&& !CollectionUtil.isEmpty(listInductionRecord_3)&&  listInductionRecord_3 !=null&& !CollectionUtil.isEmpty(listInductionRecord_3)){
      implementOrgGroupMemberChannelExitProcessComReqDto.setOldInductionRecordList(listInductionRecord_3.stream().map(item -> BeanUtil.toBean(item, OldInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443336_1
    }

    /*D1执行组织群成员通道关系处理(公共)[8199]   */
    Assert.isNull(implementOrgGroupMemberChannelExitProcessComReqDto.getMessageLocationCode(),"D1-3发布就职记录相关批次处理(公共)-D1执行组织群成员通道关系处理(公共)-消息位置标识不能为空",false);
Assert.isNull(implementOrgGroupMemberChannelExitProcessComReqDto.getBorcScene(),"D1-3发布就职记录相关批次处理(公共)-D1执行组织群成员通道关系处理(公共)-toB或toC场景不能为空",false);
      implementOrgGroupMemberChannelExitProcessComRespDto = memberService.implementOrgGroupMemberChannelExitProcessCom(implementOrgGroupMemberChannelExitProcessComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤13: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(20));//CUSTOM_CONVENTION//sourceId:284698_1
refreshMemberBatchProgressComReqDto.setBatchHandleStep("1");//CUSTOM_CONVENTION//sourceId:284699_1
refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:284700_1
refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318739_1
refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318740_1
refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318741_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:284703_1
    }
  
    /*D1-3更新组织架构成员批次处理进度20(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(),"D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(),"D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(),"D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(),"D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(),"D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(),"D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(),"D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
ReleaseInductionRecordBatchProcessingComRespDto retData = new ReleaseInductionRecordBatchProcessingComRespDto();

  

  
  
return retData;
  }
/**
   * D1-3更新组织架构成员批次处理进度(公共)[3723]
   * gen by moon at 9/20/2023, 11:29:46 PM
   */
  @Trace(operationName = "D1-3更新组织架构成员批次处理进度(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressCom(RefreshMemberBatchProgressComReqDto reqDto){
    
      
      //virtualUsage M1执行【异步开始】  11193
      //ModelCode: asynchronizationStart
Callable<String> call = new Callable<String>() {

    @Override
    public String call() throws Exception {
        //执行方法
//virtualUsage M1执行底层框架公共字段推送内存（特殊方法）  16099
      //ModelCode: publicFieldCache
        ImplementBottomPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    ImplementBottomPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBottomPublicFieldPushMemoryReqDto();
  if(reqDto!=null){
      publicFieldCacheReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:318717_1_16099
publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:318718_1_16099
publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:318719_1_16099
    }
  
    /*M1执行底层框架公共字段推送内存（特殊方法）[4519]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"D1-3更新组织架构成员批次处理进度(公共)-M1执行底层框架公共字段推送内存（特殊方法）-创建人就职记录ID 不能为空",false);
Assert.isNull(publicFieldCacheReq.getSpaceId(),"D1-3更新组织架构成员批次处理进度(公共)-M1执行底层框架公共字段推送内存（特殊方法）-创建于空间ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getAppId(),"D1-3更新组织架构成员批次处理进度(公共)-M1执行底层框架公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空",false);
      publicFieldCacheRes = nbBatch.implementBottomPublicFieldPushMemory(publicFieldCacheReq);
      
      
      
//virtualUsage M1-获取接收字段（特殊方法）  11233
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq=new QueryReceiveFieldDetailReqDto();
  if(reqDto!=null){
      receptionServiceReq.setBatchHandleSpeed(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173234_1_11233
receptionServiceReq.setBatchHandleStep(reqDto.getBatchHandleStep());//SimpleFieldAssign//sourceId:173233_1_11233
receptionServiceReq.setBatchHandleTypeCod(reqDto.getBatchHandleTypeCod());//SimpleFieldAssign//sourceId:173237_1_11233
    }
  
    /*M1-获取接收字段（特殊方法）[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBatchHandleSpeed(),"D1-3更新组织架构成员批次处理进度(公共)-M1-获取接收字段（特殊方法）-批次处理进度不能为空",false);
Assert.isNull(receptionServiceReq.getBatchHandleStep(),"D1-3更新组织架构成员批次处理进度(公共)-M1-获取接收字段（特殊方法）-处理步骤不能为空",false);
Assert.isNull(receptionServiceReq.getBatchHandleTypeCod(),"D1-3更新组织架构成员批次处理进度(公共)-M1-获取接收字段（特殊方法）-批次处理类型不能为空",false);
      receptionServiceRes = nbBatch.queryReceiveFieldDetail(receptionServiceReq);
      
      
      
//virtualUsage 1-3-12查询组织详情  15250
      Organization organization = null;
    QueryOrgDetailReq queryOrgDetailReq=new QueryOrgDetailReq();
  queryOrgDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:281993_1_15250
if(reqDto!=null){
      queryOrgDetailReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281986_1_15250
    }
  
    /*1-3-12查询组织详情[201]   */
    Assert.isNull(queryOrgDetailReq.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12查询组织详情-组织ID不能为空",false);
      organization = mOrganizationService.queryOrgDetail(queryOrgDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((reqDto!= null&&  reqDto.getBatchHandleStep() !=null && reqDto.getBatchHandleStep().equals("0")&&organization!= null&&  organization.getDelBatchIsDone() !=null && organization.getDelBatchIsDone().equals("FALSE"))&&(reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH")||reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))) {
        //if((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 0 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11267
        
Organization organization_2 = null;
    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq=new ImplementSpinLockCheckOrgReq();
  implementSpinLockCheckOrgReq.setBatchProcessProgress(Long.valueOf(-1));//CUSTOM_CONVENTION//sourceId:281937_1_15246
if(reqDto!=null){
      implementSpinLockCheckOrgReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279420_1_15246
    }
  
    /*1-3-12执行悬停查组织（悬停-1）[4304]   */
    Assert.isNull(implementSpinLockCheckOrgReq.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停-1）-组织ID不能为空",false);
Assert.isNull(implementSpinLockCheckOrgReq.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停-1）-批次处理进度不能为空",false);
      organization_2 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(organization_2== null||  organization_2.getOrganizationId() ==null,"找不到数据，系统异常",false);
      
      
boolean bOOLEAN ;
    Organization organization_4=new Organization();
  if(reqDto!=null){
      organization_4.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173155_1_11268
organization_4.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173994_1_11268
    }
  
    /*1-3-12初始化组织架构批次相关设置[197]   */
    Assert.isNull(organization_4.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12初始化组织架构批次相关设置-组织ID不能为空",false);
Assert.isNull(organization_4.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12初始化组织架构批次相关设置-批次处理进度不能为空",false);
      bOOLEAN = mOrganizationService.updateOrg(organization_4)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//processBranchName:正常结束 ,processBranchId:11269
        
      }
else if((reqDto!= null&&  reqDto.getBatchHandleStep() !=null && reqDto.getBatchHandleStep().equals("1")&&organization!= null&&  organization.getDelBatchIsDone() !=null && organization.getDelBatchIsDone().equals("FALSE"))&&(reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH")||reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))){
       //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 1 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11279
      
Organization organization_5 = null;
    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq_1=new ImplementSpinLockCheckOrgReq();
  implementSpinLockCheckOrgReq_1.setBatchProcessProgress(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:281967_1_15251
if(reqDto!=null){
      implementSpinLockCheckOrgReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281961_1_15251
    }
  
    /*1-3-12执行悬停查组织（悬停0）[4304]   */
    Assert.isNull(implementSpinLockCheckOrgReq_1.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停0）-组织ID不能为空",false);
Assert.isNull(implementSpinLockCheckOrgReq_1.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停0）-批次处理进度不能为空",false);
      organization_5 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq_1)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(organization_5== null||  organization_5.getOrganizationId() ==null,"找不到数据，系统异常",false);
      
      
boolean bOOLEAN_1 ;
    Organization organization_7=new Organization();
  if(reqDto!=null){
      organization_7.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173174_1_11280
organization_7.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173996_1_11280
    }
  
    /*1-3-12更新组织架构设置进度[197]   */
    Assert.isNull(organization_7.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-组织ID不能为空",false);
Assert.isNull(organization_7.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-批次处理进度不能为空",false);
      bOOLEAN_1 = mOrganizationService.updateOrg(organization_7)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//processBranchName:正常结束 ,processBranchId:11281
        
    }
else if((reqDto!= null&&  reqDto.getBatchHandleStep() !=null && reqDto.getBatchHandleStep().equals("2")&&organization!= null&&  organization.getDelBatchIsDone() !=null && organization.getDelBatchIsDone().equals("FALSE"))&&(reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH")||reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))){
       //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 2 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11283
      
Organization organization_8 = null;
    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq_2=new ImplementSpinLockCheckOrgReq();
  implementSpinLockCheckOrgReq_2.setBatchProcessProgress(Long.valueOf(20));//CUSTOM_CONVENTION//sourceId:281974_1_15252
if(reqDto!=null){
      implementSpinLockCheckOrgReq_2.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281968_1_15252
    }
  
    /*1-3-12执行悬停查组织（悬停20）[4304]   */
    Assert.isNull(implementSpinLockCheckOrgReq_2.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停20）-组织ID不能为空",false);
Assert.isNull(implementSpinLockCheckOrgReq_2.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停20）-批次处理进度不能为空",false);
      organization_8 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
boolean bOOLEAN_2 ;
    Organization organization_10=new Organization();
  if(reqDto!=null){
      organization_10.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173174_1_11284
organization_10.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173996_1_11284
    }
  
    /*1-3-12更新组织架构设置进度[197]   */
    Assert.isNull(organization_10.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-组织ID不能为空",false);
Assert.isNull(organization_10.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-批次处理进度不能为空",false);
      bOOLEAN_2 = mOrganizationService.updateOrg(organization_10)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//processBranchName:正常结束 ,processBranchId:11288
        
    }
else if((reqDto!= null&&  reqDto.getBatchHandleStep() !=null && reqDto.getBatchHandleStep().equals("100")&&organization!= null&&  organization.getDelBatchIsDone() !=null && organization.getDelBatchIsDone().equals("FALSE"))&&(reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH")||reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))){
       //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 100 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11285
      
Organization organization_11 = null;
    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq_3=new ImplementSpinLockCheckOrgReq();
  implementSpinLockCheckOrgReq_3.setBatchProcessProgress(Long.valueOf(80));//CUSTOM_CONVENTION//sourceId:281985_1_15253
if(reqDto!=null){
      implementSpinLockCheckOrgReq_3.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281979_1_15253
    }
  
    /*1-3-12执行悬停查组织（悬停80）[4304]   */
    Assert.isNull(implementSpinLockCheckOrgReq_3.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停80）-组织ID不能为空",false);
Assert.isNull(implementSpinLockCheckOrgReq_3.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停80）-批次处理进度不能为空",false);
      organization_11 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq_3)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
boolean bOOLEAN_3 ;
    Organization organization_13=new Organization();
  organization_13.setDelBatchIsDone("TRUE");//sourceId:173998_1_11286
if(reqDto!=null){
      organization_13.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173188_1_11286
organization_13.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173997_1_11286
    }
  
    /*1-3-12更新组织架构批次处理完成[197]   */
    Assert.isNull(organization_13.getOrganizationId(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构批次处理完成-组织ID不能为空",false);
Assert.isNull(organization_13.getBatchProcessProgress(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构批次处理完成-批次处理进度不能为空",false);
Assert.isNull(organization_13.getDelBatchIsDone(),"D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构批次处理完成-批次处理是否完成不能为空",false);
      bOOLEAN_3 = mOrganizationService.updateOrg(organization_13)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//processBranchName:正常结束 ,processBranchId:11287
        
    }
else if((reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH")||reqDto!= null&&  reqDto.getBatchHandleTypeCod() !=null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))&&(organization!= null&&  organization.getDelBatchIsDone() !=null && organization.getDelBatchIsDone().equals("0"))){
       //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销) and 1-3-12查询组织详情.批次处理是否完成 等于 --请选择--是)  11291
      
//异常结束 11294
      throw new BizException("10300051","对不起，组织架构成员修订的批次已经处理完成，不可重复操作！",false);
    }
//virtualUsage M1执行【异步结束】  11194
      //ModelCode: asynchronizationEnd
        return "";
    }
};
CommonFunctionHelper.asynExcute(call);
RefreshMemberBatchProgressComRespDto retData = new RefreshMemberBatchProgressComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1执行组织架构批次发布[3721]
   * gen by moon at 9/20/2023, 11:57:54 PM
   */
  @Trace(operationName = "D1执行组织架构批次发布")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOrgBatchPublishRespDto implementOrgBatchPublish(ImplementOrgBatchPublishReqDto reqDto){
    
      
      //步骤0: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:174087_1
refreshMemberBatchProgressComReqDto.setBatchHandleStep("0");//CUSTOM_CONVENTION//sourceId:174086_1
refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:264449_1
refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318723_1
refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318724_1
refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318725_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279564_1
    }
  
    /*D1-3更新组织架构成员批次处理进度0(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
//步骤1: D1-3发布就职记录相关批次处理(公共) - releaseInductionRecordBatchProcessingCom
     ReleaseInductionRecordBatchProcessingComRespDto releaseInductionRecordBatchProcessingComRespDto = null;
    ReleaseInductionRecordBatchProcessingComReqDto releaseInductionRecordBatchProcessingComReqDto=new ReleaseInductionRecordBatchProcessingComReqDto();
  if(reqDto!=null){
      releaseInductionRecordBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:179057_1
releaseInductionRecordBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:179058_1
    }
  
    /*D1-3发布就职记录相关批次处理(公共)[3724]   */
    Assert.isNull(releaseInductionRecordBatchProcessingComReqDto.getOrganizationId(),"D1执行组织架构批次发布-D1-3发布就职记录相关批次处理(公共)-组织ID不能为空",false);
Assert.isNull(releaseInductionRecordBatchProcessingComReqDto.getBatchId(),"D1执行组织架构批次发布-D1-3发布就职记录相关批次处理(公共)-批次ID不能为空",false);
      releaseInductionRecordBatchProcessingComRespDto = releaseInductionRecordBatchProcessingCom(releaseInductionRecordBatchProcessingComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
//步骤2: D1-1发布组织架构成员基础批次处理(公共) - releaseOrgBaseBatchProcessingCom
     ReleaseOrgBaseBatchProcessingComRespDto releaseOrgBaseBatchProcessingComRespDto = null;
    ReleaseOrgBaseBatchProcessingComReqDto releaseOrgBaseBatchProcessingComReqDto=new ReleaseOrgBaseBatchProcessingComReqDto();
  if(reqDto!=null){
      releaseOrgBaseBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279727_1
releaseOrgBaseBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176147_1
    }
  
    /*D1-1发布组织架构成员基础批次处理(公共)[3726]   */
    Assert.isNull(releaseOrgBaseBatchProcessingComReqDto.getOrganizationId(),"D1执行组织架构批次发布-D1-1发布组织架构成员基础批次处理(公共)-组织ID不能为空",false);
Assert.isNull(releaseOrgBaseBatchProcessingComReqDto.getBatchId(),"D1执行组织架构批次发布-D1-1发布组织架构成员基础批次处理(公共)-批次ID不能为空",false);
      releaseOrgBaseBatchProcessingComRespDto = releaseOrgBaseBatchProcessingCom(releaseOrgBaseBatchProcessingComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
//步骤3: 1-3-12修改组织 - updateOrg
     boolean bOOLEAN ;
    Organization organization=new Organization();
  organization.setCurrentManageObjectType("UNMANNED_MGT");//sourceId:304394_1
organization.setManageLockStatus("AUTO_LOCK");//sourceId:304389_1
organization.setReasonOfManageLock("组织架构成员已确认设置完成，锁定停止维护。");//CUSTOM_CONVENTION//sourceId:304390_1
organization.setUsingLockStatus("UNLOCK");//sourceId:304392_1
organization.setReasonOfUsingLock("---");//NULL//sourceId:304391_1
if(reqDto!=null){
      organization.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:304386_1
    }
  
    /*1-3-12修改组织锁定状态等[197]   */
    Assert.isNull(organization.getOrganizationId(),"D1执行组织架构批次发布-1-3-12修改组织锁定状态等-组织ID不能为空",false);
Assert.isNull(organization.getCurrentManageObjectType(),"D1执行组织架构批次发布-1-3-12修改组织锁定状态等-当前管理对象类型不能为空",false);
Assert.isNull(organization.getManageLockStatus(),"D1执行组织架构批次发布-1-3-12修改组织锁定状态等-管理锁定状态不能为空",false);
Assert.isNull(organization.getReasonOfManageLock(),"D1执行组织架构批次发布-1-3-12修改组织锁定状态等-管理锁定原因不能为空",false);
Assert.isNull(organization.getUsingLockStatus(),"D1执行组织架构批次发布-1-3-12修改组织锁定状态等-使用锁定状态不能为空",false);
Assert.isNull(organization.getReasonOfUsingLock(),"D1执行组织架构批次发布-1-3-12修改组织锁定状态等-使用锁定原因不能为空",false);
      bOOLEAN = mOrganizationService.updateOrg(organization)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤4: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto_1 = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto_1=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto_1.setBatchHandleSpeed(Long.valueOf(100));//CUSTOM_CONVENTION//sourceId:264450_1
refreshMemberBatchProgressComReqDto_1.setBatchHandleStep("100");//CUSTOM_CONVENTION//sourceId:175433_1
refreshMemberBatchProgressComReqDto_1.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:175434_1
refreshMemberBatchProgressComReqDto_1.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318728_1
refreshMemberBatchProgressComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318729_1
refreshMemberBatchProgressComReqDto_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318730_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279565_1
    }
  
    /*D1-3更新组织架构成员批次处理进度100(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto_1.getOrganizationId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleSpeed(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleStep(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleTypeCod(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getCreateInductionId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getSpaceId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getAppId(),"D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto_1 = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto_1)/*vcase invoke 同服务,同domain*/;




//步骤5: D1-执行清理空间管理员临时就职记录(公共) - implementCleanSpaceAdminTtemporarynductionCom
     ImplementCleanSpaceAdminTtemporarynductionComRespDto implementCleanSpaceAdminTtemporarynductionComRespDto = null;
    ImplementCleanSpaceAdminTtemporarynductionComReqDto implementCleanSpaceAdminTtemporarynductionComReqDto=new ImplementCleanSpaceAdminTtemporarynductionComReqDto();
  if(reqDto!=null){
      implementCleanSpaceAdminTtemporarynductionComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:1128702_1
    }

    /*D1-执行清理空间管理员临时就职记录(公共)[7429]   */
    Assert.isNull(implementCleanSpaceAdminTtemporarynductionComReqDto.getOrganizationId(),"D1执行组织架构批次发布-D1-执行清理空间管理员临时就职记录(公共)-组织ID不能为空",false);
      implementCleanSpaceAdminTtemporarynductionComRespDto = inductionRecordService.implementCleanSpaceAdminTtemporarynductionCom(implementCleanSpaceAdminTtemporarynductionComReqDto)/*vcase invoke isSameApp*/;
      
      
      
    
ImplementOrgBatchPublishRespDto retData = new ImplementOrgBatchPublishRespDto();
  
  

  
  
return retData;
  }
/**
   * D1执行组织架构撤销批次[3722]
   * gen by moon at 10/2/2022, 3:48:35 AM
   */
  @Trace(operationName = "D1执行组织架构撤销批次")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOrgDeleteBatchRespDto implementOrgDeleteBatch(ImplementOrgDeleteBatchReqDto reqDto){
    
      
      //步骤0: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(0L);//CUSTOM_CONVENTION//sourceId:264451_1
refreshMemberBatchProgressComReqDto.setBatchHandleStep("0");//CUSTOM_CONVENTION//sourceId:175437_1
refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:175438_1
refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318731_1
refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318733_1
refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318732_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279566_1
    }
  
    /*D1-3更新组织架构成员批次处理进度0(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-批次处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto);
      
      
      
    
//步骤1: D1-3撤销就职记录相关批次处理(公共) - undoInductionRecordBatchProcessingCom
     UndoInductionRecordBatchProcessingComRespDto undoInductionRecordBatchProcessingComRespDto = null;
    UndoInductionRecordBatchProcessingComReqDto undoInductionRecordBatchProcessingComReqDto=new UndoInductionRecordBatchProcessingComReqDto();
  if(reqDto!=null){
      undoInductionRecordBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176617_1
undoInductionRecordBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176618_1
    }
  
    /*D1-3撤销就职记录相关批次处理(公共)[3725]   */
    Assert.isNull(undoInductionRecordBatchProcessingComReqDto.getOrganizationId(),"D1执行组织架构撤销批次-D1-3撤销就职记录相关批次处理(公共)-组织ID不能为空",false);
Assert.isNull(undoInductionRecordBatchProcessingComReqDto.getBatchId(),"D1执行组织架构撤销批次-D1-3撤销就职记录相关批次处理(公共)-批次ID不能为空",false);
      undoInductionRecordBatchProcessingComRespDto = undoInductionRecordBatchProcessingCom(undoInductionRecordBatchProcessingComReqDto);
      
      
      
    
//步骤2: D1-1撤销组织架构成员基础批次处理(公共) - undoOrgBaseBatchProcessingCom
     UndoOrgBaseBatchProcessingComRespDto undoOrgBaseBatchProcessingComRespDto = null;
    UndoOrgBaseBatchProcessingComReqDto undoOrgBaseBatchProcessingComReqDto=new UndoOrgBaseBatchProcessingComReqDto();
  if(reqDto!=null){
      undoOrgBaseBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279785_1
undoOrgBaseBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176149_1
    }
  
    /*D1-1撤销组织架构成员基础批次处理(公共)[3727]   */
    Assert.isNull(undoOrgBaseBatchProcessingComReqDto.getOrganizationId(),"D1执行组织架构撤销批次-D1-1撤销组织架构成员基础批次处理(公共)-组织ID不能为空",false);
Assert.isNull(undoOrgBaseBatchProcessingComReqDto.getBatchId(),"D1执行组织架构撤销批次-D1-1撤销组织架构成员基础批次处理(公共)-批次ID不能为空",false);
      undoOrgBaseBatchProcessingComRespDto = undoOrgBaseBatchProcessingCom(undoOrgBaseBatchProcessingComReqDto);
      
      
      
    
//步骤3: 1-3-12修改组织 - updateOrg
     boolean bOOLEAN ;
    Organization organization=new Organization();
  organization.setCurrentManageObjectType("UNMANNED_MGT");//sourceId:304405_1
organization.setManageLockStatus("AUTO_LOCK");//sourceId:304400_1
organization.setReasonOfManageLock("组织架构成员已确认设置完成，锁定停止维护。");//CUSTOM_CONVENTION//sourceId:304401_1
organization.setUsingLockStatus("UNLOCK");//sourceId:304403_1
organization.setReasonOfUsingLock("---");//NULL//sourceId:304402_1
if(reqDto!=null){
      organization.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:304397_1
    }
  
    /*1-3-12修改组织锁定状态等[197]   */
    Assert.isNull(organization.getOrganizationId(),"D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-组织ID不能为空",false);
Assert.isNull(organization.getCurrentManageObjectType(),"D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-当前管理对象类型不能为空",false);
Assert.isNull(organization.getManageLockStatus(),"D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-管理锁定状态不能为空",false);
Assert.isNull(organization.getReasonOfManageLock(),"D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-管理锁定原因不能为空",false);
Assert.isNull(organization.getUsingLockStatus(),"D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-使用锁定状态不能为空",false);
Assert.isNull(organization.getReasonOfUsingLock(),"D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-使用锁定原因不能为空",false);
      bOOLEAN = mOrganizationService.updateOrg(organization);
      
      
      
    
//步骤4: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
     RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto_1 = null;
    RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto_1=new RefreshMemberBatchProgressComReqDto();
  refreshMemberBatchProgressComReqDto_1.setBatchHandleSpeed(100L);//CUSTOM_CONVENTION//sourceId:175440_1
refreshMemberBatchProgressComReqDto_1.setBatchHandleStep("100");//CUSTOM_CONVENTION//sourceId:175441_1
refreshMemberBatchProgressComReqDto_1.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:175442_1
refreshMemberBatchProgressComReqDto_1.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318736_1
refreshMemberBatchProgressComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318737_1
refreshMemberBatchProgressComReqDto_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318738_1
if(reqDto!=null){
      refreshMemberBatchProgressComReqDto_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279730_1
    }
  
    /*D1-3更新组织架构成员批次处理进度100(公共)[3723]   */
    Assert.isNull(refreshMemberBatchProgressComReqDto_1.getOrganizationId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-组织ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleSpeed(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-批次处理进度不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleStep(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-批次处理步骤不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleTypeCod(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-批次处理类型不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getCreateInductionId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getSpaceId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshMemberBatchProgressComReqDto_1.getAppId(),"D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-创建于联盟应用ID不能为空",false);
      refreshMemberBatchProgressComRespDto_1 = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto_1);
      
      
      
    
ImplementOrgDeleteBatchRespDto retData = new ImplementOrgDeleteBatchRespDto();
  
  

  
  
return retData;
  }

/**
   * D1-3判断发起组织批次操作可用(公共)[4150]
   * gen by moon at 10/1/2022, 11:50:54 PM
   */
  @Trace(operationName = "D1-3判断发起组织批次操作可用(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeInitiateOrgBatchUsableComRespDto judgeInitiateOrgBatchUsableCom(JudgeInitiateOrgBatchUsableComReqDto reqDto){
    
      
      JudgeOrgOnlyPowerComRespDto judgeOrgOnlyPowerComRespDto_1 =null;
//virtualUsage 1-1-01查询是否有正在编辑的批次，避免重复  14072
      Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq.setPurposeTypeCode("ORG");//sourceId:246732_1_14072
queryBaseBatchDetailReq.setSubjectLifeCycle("EDITING");//sourceId:246773_1_14072
if(reqDto!=null){
      queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246733_1_14072
    }
  
    /*1-1-01查询是否有正在编辑的批次，避免重复[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(),"D1-3判断发起组织批次操作可用(公共)-1-1-01查询是否有正在编辑的批次，避免重复-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(),"D1-3判断发起组织批次操作可用(公共)-1-1-01查询是否有正在编辑的批次，避免重复-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(),"D1-3判断发起组织批次操作可用(公共)-1-1-01查询是否有正在编辑的批次，避免重复-主体生命周期不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);
      
      
if((batch == null )) {
        //if(1-1-01查询是否有正在编辑的批次，避免重复.出参 值等于空 )  14073
        
JudgeOrgOnlyPowerComRespDto judgeOrgOnlyPowerComRespDto = null;
    JudgeOrgOnlyPowerComReqDto judgeOrgOnlyPowerComReqDto=new JudgeOrgOnlyPowerComReqDto();
  judgeOrgOnlyPowerComReqDto.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:246721_1_14074
judgeOrgOnlyPowerComReqDto.setPrivacyCode("MGT_ORG_POWER");//CUSTOM_CONVENTION//sourceId:246722_1_14074
judgeOrgOnlyPowerComReqDto.setBatchMgtOperationType("START_MGT_OBJ");//sourceId:246727_1_14074
if(reqDto!=null){
      judgeOrgOnlyPowerComReqDto.setOrganizationId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246723_1_14074
    }
  
    /*D1判断组织架构唯一权限(公共)[3877]   */
    Assert.isNull(judgeOrgOnlyPowerComReqDto.getOrganizationId(),"D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-组织ID不能为空",false);
Assert.isNull(judgeOrgOnlyPowerComReqDto.getRoleCode(),"D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-角色标识不能为空",false);
Assert.isNull(judgeOrgOnlyPowerComReqDto.getPrivacyCode(),"D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-权限标识不能为空",false);
Assert.isNull(judgeOrgOnlyPowerComReqDto.getBatchMgtOperationType(),"D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-批次下管理操作类型不能为空",false);
      judgeOrgOnlyPowerComRespDto = powerService.judgeOrgOnlyPowerCom(judgeOrgOnlyPowerComReqDto);
      Assert.isTrue(judgeOrgOnlyPowerComRespDto== null||  judgeOrgOnlyPowerComRespDto.getOutputNum() ==null,"返回值不能为空",false);

      judgeOrgOnlyPowerComRespDto_1 = judgeOrgOnlyPowerComRespDto;
//processBranchName:正常结束 ,processBranchId:14075
        
      }
else{
       //else  14076
      
//异常结束 14077
      throw new BizException("B10000081","对不起！批次已存在，请直接进入管理~！",false);
    }
JudgeInitiateOrgBatchUsableComRespDto retData = new JudgeInitiateOrgBatchUsableComRespDto();
  if(judgeOrgOnlyPowerComRespDto_1!=null){
      retData.setOutputNum(judgeOrgOnlyPowerComRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:246778_1
retData.setBatchId(judgeOrgOnlyPowerComRespDto_1.getBatchId());//SimpleFieldAssign//sourceId:246779_1
retData.setBatchCurrentStatus(judgeOrgOnlyPowerComRespDto_1.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:246780_1
    }
  

  
  
return retData;
  }
/**
   * D1-1新增组织批次[242]
   * gen by moon at 10/2/2022, 2:47:46 AM
   */
  @Trace(operationName = "D1-1新增组织批次")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddOrgBatchRespDto addOrgBatch(AddOrgBatchReqDto reqDto){
    
      
      String string_1 =null;
String string_3 =null;
//virtualUsage D1-3判断发起组织批次操作可用(公共)  14079
      JudgeInitiateOrgBatchUsableComRespDto judgeInitiateOrgBatchUsableComRespDto = null;
    JudgeInitiateOrgBatchUsableComReqDto judgeInitiateOrgBatchUsableComReqDto=new JudgeInitiateOrgBatchUsableComReqDto();
  if(reqDto!=null){
      judgeInitiateOrgBatchUsableComReqDto.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246782_1_14079
    }
  
    /*D1-3判断发起组织批次操作可用(公共)[4150]   */
    Assert.isNull(judgeInitiateOrgBatchUsableComReqDto.getAscriptionObjectId(),"D1-1新增组织批次-D1-3判断发起组织批次操作可用(公共)-归属对象ID不能为空",false);
      judgeInitiateOrgBatchUsableComRespDto = judgeInitiateOrgBatchUsableCom(judgeInitiateOrgBatchUsableComReqDto);
      Assert.isTrue(judgeInitiateOrgBatchUsableComRespDto== null||  judgeInitiateOrgBatchUsableComRespDto.getOutputNum() ==null,"返回值不能为空",false);

      
//virtualUsage 1-1-01查询组织架构批次（用于判断是否首次批次）  14080
      Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq.setPurposeTypeCode("ORG");//sourceId:246797_1_14080
queryBaseBatchDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285051_1_14080
if(reqDto!=null){
      queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246798_1_14080
    }
  
    /*1-1-01查询组织架构批次（用于判断是否首次批次）[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(),"D1-1新增组织批次-1-1-01查询组织架构批次（用于判断是否首次批次）-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(),"D1-1新增组织批次-1-1-01查询组织架构批次（用于判断是否首次批次）-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(),"D1-1新增组织批次-1-1-01查询组织架构批次（用于判断是否首次批次）-主体生命周期不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);
      
      
if((batch == null )) {
        //if(1-1-01查询组织架构批次（用于判断是否首次批次）.出参 值等于空 )  14081
        
String string = null;
    Batch batch_2=new Batch();
  batch_2.setBatchName(CommonFunctionHelper.getUid());//AUTO_GENERATE//sourceId:323538_1_14082
batch_2.setPurposeTypeCode("ORG");//sourceId:3459_1_14082
batch_2.setIsNewbatch("TRUE");//sourceId:246848_1_14082
batch_2.setIsFirst("TRUE");//sourceId:17396_1_14082
batch_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23641_1_14082
batch_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23642_1_14082
if(reqDto!=null){
      batch_2.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:3460_1_14082
    }
  
    /*1-1-01新增组织架构批次（首次）[41]   */
    Assert.isNull(batch_2.getBatchName(),"D1-1新增组织批次-1-1-01新增组织架构批次（首次）-批次名称不能为空",false);
Assert.isNull(batch_2.getAscriptionObjectId(),"D1-1新增组织批次-1-1-01新增组织架构批次（首次）-归属对象ID不能为空",false);
Assert.isNull(batch_2.getPurposeTypeCode(),"D1-1新增组织批次-1-1-01新增组织架构批次（首次）-用途类型编码不能为空",false);
Assert.isNull(batch_2.getIsNewbatch(),"D1-1新增组织批次-1-1-01新增组织架构批次（首次）-是否最新批次不能为空",false);
Assert.isNull(batch_2.getIsFirst(),"D1-1新增组织批次-1-1-01新增组织架构批次（首次）-是否首次批次不能为空",false);
Assert.isNull(batch_2.getSpaceId(),"D1-1新增组织批次-1-1-01新增组织架构批次（首次）-创建于空间ID不能为空",false);
Assert.isNull(batch_2.getAppId(),"D1-1新增组织批次-1-1-01新增组织架构批次（首次）-创建于联盟应用ID不能为空",false);
      string = mBatchService.addBaseBatch(batch_2);
      
      string_1 = string;
boolean bOOLEAN ;
    if(string !=null){
          Organization organization=new Organization();
  organization.setCurrentManageObjectType("MEMBER");//sourceId:246717_1_14098
organization.setManageLockStatus("UNLOCK");//sourceId:246712_1_14098
organization.setUsingLockStatus("AUTO_LOCK");//sourceId:246715_1_14098
organization.setReasonOfUsingLock("组织架构正在维护，暂停使用，请耐心等待～");//CUSTOM_CONVENTION//sourceId:246714_1_14098
organization.setBatchProcessProgress(-1L);//CUSTOM_CONVENTION//sourceId:247259_1_14098
organization.setDelBatchIsDone("FALSE");//sourceId:247260_1_14098
if(reqDto!=null){
      organization.setOrganizationId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246709_1_14098
    }
if(string!=null){
      organization.setBatchId(string);//SimpleFieldAssign//sourceId:246716_1_14098
    }
  
    /*1-3-12修改组织[197]   */
    Assert.isNull(organization.getOrganizationId(),"D1-1新增组织批次-1-3-12修改组织-组织ID不能为空",false);
Assert.isNull(organization.getCurrentManageObjectType(),"D1-1新增组织批次-1-3-12修改组织-当前管理对象类型不能为空",false);
Assert.isNull(organization.getManageLockStatus(),"D1-1新增组织批次-1-3-12修改组织-管理锁定状态不能为空",false);
Assert.isNull(organization.getUsingLockStatus(),"D1-1新增组织批次-1-3-12修改组织-使用锁定状态不能为空",false);
Assert.isNull(organization.getReasonOfUsingLock(),"D1-1新增组织批次-1-3-12修改组织-使用锁定原因不能为空",false);
Assert.isNull(organization.getBatchProcessProgress(),"D1-1新增组织批次-1-3-12修改组织-批次处理进度不能为空",false);
Assert.isNull(organization.getDelBatchIsDone(),"D1-1新增组织批次-1-3-12修改组织-批次处理是否完成不能为空",false);
Assert.isNull(organization.getBatchId(),"D1-1新增组织批次-1-3-12修改组织-批次ID不能为空",false);
      bOOLEAN = mOrganizationService.updateOrg(organization);
      
      
           }
      }
else{
       //else  14083
      
String string_2 = null;
    Batch batch_3=new Batch();
  batch_3.setBatchName(CommonFunctionHelper.getUid());//AUTO_GENERATE//sourceId:351236_1_14084
batch_3.setPurposeTypeCode("ORG");//sourceId:246839_1_14084
batch_3.setIsFirst("FALSE");//sourceId:246844_1_14084
batch_3.setIsNewbatch("TRUE");//sourceId:246995_1_14084
batch_3.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:246996_1_14084
batch_3.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:246997_1_14084
if(reqDto!=null){
      batch_3.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246840_1_14084
    }
  
    /*1-1-01新增组织架构批次（后续）[41]   */
    Assert.isNull(batch_3.getAscriptionObjectId(),"D1-1新增组织批次-1-1-01新增组织架构批次（后续）-归属对象ID不能为空",false);
Assert.isNull(batch_3.getBatchName(),"D1-1新增组织批次-1-1-01新增组织架构批次（后续）-批次名称不能为空",false);
Assert.isNull(batch_3.getPurposeTypeCode(),"D1-1新增组织批次-1-1-01新增组织架构批次（后续）-用途类型编码不能为空",false);
Assert.isNull(batch_3.getIsFirst(),"D1-1新增组织批次-1-1-01新增组织架构批次（后续）-是否首次批次不能为空",false);
Assert.isNull(batch_3.getIsNewbatch(),"D1-1新增组织批次-1-1-01新增组织架构批次（后续）-是否最新批次不能为空",false);
Assert.isNull(batch_3.getSpaceId(),"D1-1新增组织批次-1-1-01新增组织架构批次（后续）-创建于空间ID不能为空",false);
Assert.isNull(batch_3.getAppId(),"D1-1新增组织批次-1-1-01新增组织架构批次（后续）-创建于联盟应用ID不能为空",false);
      string_2 = mBatchService.addBaseBatch(batch_3);
      
      string_3 = string_2;
boolean bOOLEAN_1 ;
    if(batch !=null){
          Batch batch_4=new Batch();
  batch_4.setIsNewbatch("FALSE");//sourceId:285073_1_15255
batch_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:285071_1_15255
batch_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:285072_1_15255
if(batch!=null){
      batch_4.setBatchId(batch.getBatchId());//SimpleFieldAssign//sourceId:285068_1_15255
    }
  
    /*1-1-01回改底层框架服务批次（是否最新批次）[42]   */
    Assert.isNull(batch_4.getBatchId(),"D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-批次ID不能为空",false);
Assert.isNull(batch_4.getIsNewbatch(),"D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-是否最新批次不能为空",false);
Assert.isNull(batch_4.getOperationInductionId(),"D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-操作人就职记录ID不能为空",false);
Assert.isNull(batch_4.getOperateTime(),"D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-操作时间不能为空",false);
      bOOLEAN_1 = mBatchService.updateBaseBatch(batch_4);
      
      
           }
boolean bOOLEAN_2 ;
    if(string_2 !=null){
          Organization organization_1=new Organization();
  organization_1.setCurrentManageObjectType("MEMBER");//sourceId:246717_1_14099
organization_1.setManageLockStatus("UNLOCK");//sourceId:246712_1_14099
organization_1.setUsingLockStatus("AUTO_LOCK");//sourceId:246715_1_14099
organization_1.setReasonOfUsingLock("组织架构正在维护，暂停使用，请耐心等待～");//CUSTOM_CONVENTION//sourceId:246714_1_14099
organization_1.setBatchProcessProgress(-1L);//CUSTOM_CONVENTION//sourceId:247259_1_14099
organization_1.setDelBatchIsDone("FALSE");//sourceId:247260_1_14099
if(reqDto!=null){
      organization_1.setOrganizationId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246709_1_14099
    }
if(string_2!=null){
      organization_1.setBatchId(string_2);//SimpleFieldAssign//sourceId:246716_1_14099
    }
  
    /*1-3-12修改组织[197]   */
    Assert.isNull(organization_1.getOrganizationId(),"D1-1新增组织批次-1-3-12修改组织-组织ID不能为空",false);
Assert.isNull(organization_1.getCurrentManageObjectType(),"D1-1新增组织批次-1-3-12修改组织-当前管理对象类型不能为空",false);
Assert.isNull(organization_1.getManageLockStatus(),"D1-1新增组织批次-1-3-12修改组织-管理锁定状态不能为空",false);
Assert.isNull(organization_1.getUsingLockStatus(),"D1-1新增组织批次-1-3-12修改组织-使用锁定状态不能为空",false);
Assert.isNull(organization_1.getReasonOfUsingLock(),"D1-1新增组织批次-1-3-12修改组织-使用锁定原因不能为空",false);
Assert.isNull(organization_1.getBatchProcessProgress(),"D1-1新增组织批次-1-3-12修改组织-批次处理进度不能为空",false);
Assert.isNull(organization_1.getDelBatchIsDone(),"D1-1新增组织批次-1-3-12修改组织-批次处理是否完成不能为空",false);
Assert.isNull(organization_1.getBatchId(),"D1-1新增组织批次-1-3-12修改组织-批次ID不能为空",false);
      bOOLEAN_2 = mOrganizationService.updateOrg(organization_1);
      
      
           }
    }
//virtualUsage D1-1修改检查项状态(组织成员管理检查项)  14094
      UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
    UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto=new UpdateCheckItemStatComReqDto();
  updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144788_1_14094
updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144789_1_14094
updateCheckItemStatComReqDto.setIsComplete("FALSE");//sourceId:144787_1_14094
if(reqDto!=null){
      updateCheckItemStatComReqDto.setEntityId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:144790_1_14094
    }
  
    /*D1-1修改检查项状态(组织成员管理检查项)[947]   */
    Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(),"D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(),"D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getEntityId(),"D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(),"D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-是否已完成不能为空",false);
      updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);
      
      
//virtualUsage D1-1修改检查项状态(公共)(组织管理检查项)  14095
      UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto_1 = null;
    UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto_1=new UpdateCheckItemStatComReqDto();
  updateCheckItemStatComReqDto_1.setCheckItemCode("ORG_MGT_CHECK");//CUSTOM_CONVENTION//sourceId:246788_1_14095
updateCheckItemStatComReqDto_1.setObjectTypeCode("ORG_CHECK");//sourceId:246789_1_14095
updateCheckItemStatComReqDto_1.setIsComplete("FALSE");//sourceId:246787_1_14095
if(reqDto!=null){
      updateCheckItemStatComReqDto_1.setEntityId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246790_1_14095
    }
  
    /*D1-1修改检查项状态(公共)(组织管理检查项)[947]   */
    Assert.isNull(updateCheckItemStatComReqDto_1.getCheckItemCode(),"D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto_1.getObjectTypeCode(),"D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto_1.getEntityId(),"D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto_1.getIsComplete(),"D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-是否已完成不能为空",false);
      updateCheckItemStatComRespDto_1 = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto_1);
      
      
//processBranchName:正常结束 ,processBranchId:14097
        
AddOrgBatchRespDto retData = new AddOrgBatchRespDto();
  if(string_1!=null){
      retData.setBatchId(string_1);//SimpleFieldAssign//sourceId:246793_1
    }
if(string_3!=null){
      retData.setBatchId(string_3);//SimpleFieldAssign//sourceId:246793_1
    }
  

  
  
return retData;
  }
/**
   * D1判断组织架构进入管理可用(公共)[3813]
   * gen by moon at 8/24/2023, 1:19:04 PM
   */
  @Trace(operationName = "D1判断组织架构进入管理可用(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeOrgStructureMgtUsableComRespDto judgeOrgStructureMgtUsableCom(JudgeOrgStructureMgtUsableComReqDto reqDto){
    
      
      Batch batch_1 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_7 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_9 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_11 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_13 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_15 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_17 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_19 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_21 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_23 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_25 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_27 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_29 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_31 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_33 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_35 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_37 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_39 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_59 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_61 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_63 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_65 =null;
//virtualUsage M1-传输0  14039
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq.setOutputNum(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:245169_1_14039
  
    /*M1-传输0[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOutputNum(),"D1判断组织架构进入管理可用(公共)-M1-传输0-传输数值（整数型）不能为空",false);
      receptionServiceRes = nbBatch.queryReceiveFieldDetail(receptionServiceReq);
      
      
      
//virtualUsage M1-传输1  14042
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_1=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_1.setOutputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:245170_1_14042
  
    /*M1-传输1[3715]  用于特殊方法接收上游入参。 */
    
      receptionServiceRes_2 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_1);
      
      
      
//virtualUsage M-传输2  14041
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_4 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_2=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_2.setOutputNum(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:245229_1_14041
  
    /*M-传输2[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getOutputNum(),"D1判断组织架构进入管理可用(公共)-M-传输2-传输数值（整数型）不能为空",false);
      receptionServiceRes_4 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_2);
      
      
      
//virtualUsage 1-1-01查询当前最新批次信息  11910
      Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq.setPurposeTypeCode("ORG");//sourceId:183442_1_11910
queryBaseBatchDetailReq.setIsNewbatch("TRUE");//sourceId:183547_1_11910
if(reqDto!=null){
      queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:183443_1_11910
    }
  
    /*1-1-01查询当前最新批次信息[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(),"D1判断组织架构进入管理可用(公共)-1-1-01查询当前最新批次信息-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(),"D1判断组织架构进入管理可用(公共)-1-1-01查询当前最新批次信息-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getIsNewbatch(),"D1判断组织架构进入管理可用(公共)-1-1-01查询当前最新批次信息-是否最新批次不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      batch_1 = batch;
//virtualUsage 1-3-12查询组织管理状态等信息  11911
      Organization organization = null;
    QueryOrgDetailReq queryOrgDetailReq=new QueryOrgDetailReq();
  queryOrgDetailReq.setIsArchive("FALSE");//sourceId:183463_1_11911
if(reqDto!=null){
      queryOrgDetailReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:183446_1_11911
    }
  
    /*1-3-12查询组织管理状态等信息[201]   */
    Assert.isNull(queryOrgDetailReq.getOrganizationId(),"D1判断组织架构进入管理可用(公共)-1-3-12查询组织管理状态等信息-组织ID不能为空",false);
Assert.isNull(queryOrgDetailReq.getIsArchive(),"D1判断组织架构进入管理可用(公共)-1-3-12查询组织管理状态等信息-是否存档不能为空",false);
      organization = mOrganizationService.queryOrgDetail(queryOrgDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//virtualUsage 1-1-22查询组织架构管理检查项状态  11935
      StatusCheckItem statusCheckItem = null;
    QueryCheckItemStatDetailReq queryCheckItemStatDetailReq=new QueryCheckItemStatDetailReq();
  queryCheckItemStatDetailReq.setCheckItemCode("ORG_MGT_CHECK");//CUSTOM_CONVENTION//sourceId:184139_1_11935
queryCheckItemStatDetailReq.setObjectTypeCode("ORG_CHECK");//sourceId:184140_1_11935
if(reqDto!=null){
      queryCheckItemStatDetailReq.setEntityId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:184141_1_11935
    }
  
    /*1-1-22查询组织架构管理检查项状态[327]   */
    Assert.isNull(queryCheckItemStatDetailReq.getCheckItemCode(),"D1判断组织架构进入管理可用(公共)-1-1-22查询组织架构管理检查项状态-检查项标识不能为空",false);
Assert.isNull(queryCheckItemStatDetailReq.getObjectTypeCode(),"D1判断组织架构进入管理可用(公共)-1-1-22查询组织架构管理检查项状态-内容对象类型编码不能为空",false);
Assert.isNull(queryCheckItemStatDetailReq.getEntityId(),"D1判断组织架构进入管理可用(公共)-1-1-22查询组织架构管理检查项状态-内容对象实例ID不能为空",false);
      statusCheckItem = mStatusCheckItemService.queryCheckItemStatDetail(queryCheckItemStatDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(statusCheckItem== null||  statusCheckItem.getStatusCheckItemId() ==null,"找不到数据，系统异常",false);
      
      
//virtualUsage 1-3-16查询部门类型字典列表  14060
      List<TypeDictionary> listTypeDictionary =new ArrayList<>();
    QueryOrgClassListReq queryOrgClassListReq=new QueryOrgClassListReq();
  queryOrgClassListReq.setPurposeCode("DEPT_TYPE");//sourceId:245600_1_14060
queryOrgClassListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:245604_1_14060
queryOrgClassListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:245607_1_14060
if(reqDto!=null){
      queryOrgClassListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:245601_1_14060
    }
  
    /*1-3-16查询部门类型字典列表[295]   */
    Assert.isNull(queryOrgClassListReq.getOrganizationId(),"D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-组织ID不能为空",false);
Assert.isNull(queryOrgClassListReq.getPurposeCode(),"D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-类型用途编码不能为空",false);
Assert.isNull(queryOrgClassListReq.getSubjectLifeCycle(),"D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-主体生命周期不能为空",false);
Assert.isNull(queryOrgClassListReq.getSpaceId(),"D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-创建于空间ID不能为空",false);
      listTypeDictionary = mTypeDictionaryService.queryOrgClassList(queryOrgClassListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//virtualUsage 1-3-09查询部门列表（用于判断成员开始管理是否可用）  14085
      List<Dept> listDept =new ArrayList<>();
    QueryDeptListReq queryDeptListReq=new QueryDeptListReq();
  queryDeptListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:246862_1_14085
if(reqDto!=null){
      queryDeptListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:246860_1_14085
    }
  
    /*1-3-09查询部门列表（用于判断成员开始管理是否可用）[217]   */
    Assert.isNull(queryDeptListReq.getOrganizationId(),"D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断成员开始管理是否可用）-组织ID不能为空",false);
Assert.isNull(queryDeptListReq.getSubjectLifeCycle(),"D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断成员开始管理是否可用）-主体生命周期不能为空",false);
      listDept = mDeptService.queryDeptList(queryDeptListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//virtualUsage 1-3-09查询部门列表（用于判断部门维护完成是否可用）  15280
      List<Dept> listDept_2 =new ArrayList<>();
    QueryDeptListReq queryDeptListReq_1=new QueryDeptListReq();
  queryDeptListReq_1.setSubjectLifeCycle("EDITING");//sourceId:286091_1_15280
if(reqDto!=null){
      queryDeptListReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:286089_1_15280
    }
  
    /*1-3-09查询部门列表（用于判断部门维护完成是否可用）[217]   */
    Assert.isNull(queryDeptListReq_1.getOrganizationId(),"D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断部门维护完成是否可用）-组织ID不能为空",false);
Assert.isNull(queryDeptListReq_1.getSubjectLifeCycle(),"D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断部门维护完成是否可用）-主体生命周期不能为空",false);
      listDept_2 = mDeptService.queryDeptList(queryDeptListReq_1)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//virtualUsage M1-成员开始管理  14043
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_6 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_3=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setStartMgtObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:184161_1_14043
    }
  
    /*M1-成员开始管理[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getStartMgtObj(),"D1判断组织架构进入管理可用(公共)-M1-成员开始管理-开始管理不能为空",false);
      receptionServiceRes_6 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_3);
      
      
      receptionServiceRes_7 = receptionServiceRes_6;
//virtualUsage M1-成员暂停对外使用  14044
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_8 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_4=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setSuspendedObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183849_1_14044
    }
  
    /*M1-成员暂停对外使用[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getSuspendedObj(),"D1判断组织架构进入管理可用(公共)-M1-成员暂停对外使用-暂停对外使用不能为空",false);
      receptionServiceRes_8 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_4);
      
      
      receptionServiceRes_9 = receptionServiceRes_8;
//virtualUsage M1-成员恢复对外使用  14056
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_10 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_5=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setRestoreObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183851_1_14056
    }
  
    /*M1-成员恢复对外使用[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getRestoreObj(),"D1判断组织架构进入管理可用(公共)-M1-成员恢复对外使用-恢复对外使用不能为空",false);
      receptionServiceRes_10 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_5);
      
      
      receptionServiceRes_11 = receptionServiceRes_10;
//virtualUsage M1-成员发布生效  14045
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_12 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_6=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_6.setReleaseEffectObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183741_1_14045
    }
  
    /*M1-成员发布生效[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getReleaseEffectObj(),"D1判断组织架构进入管理可用(公共)-M1-成员发布生效-发布生效不能为空",false);
      receptionServiceRes_12 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_6);
      
      
      receptionServiceRes_13 = receptionServiceRes_12;
//virtualUsage M1-成员取消设置完成  14046
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_14 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_7=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_7.setCancelSetCompleteObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183747_1_14046
    }
  
    /*M1-成员取消设置完成[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getCancelSetCompleteObj(),"D1判断组织架构进入管理可用(公共)-M1-成员取消设置完成-取消设置完成不能为空",false);
      receptionServiceRes_14 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_7);
      
      
      receptionServiceRes_15 = receptionServiceRes_14;
//virtualUsage M1-成员确认设置完成  14047
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_16 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_8=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_8.setSetCompleteObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183745_1_14047
    }
  
    /*M1-成员确认设置完成[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_8.getSetCompleteObj(),"D1判断组织架构进入管理可用(公共)-M1-成员确认设置完成-确认设置完成不能为空",false);
      receptionServiceRes_16 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_8);
      
      
      receptionServiceRes_17 = receptionServiceRes_16;
//virtualUsage M1-成员撤销修订  14048
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_18 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_9=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_9.setCancelRevisionObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183744_1_14048
    }
  
    /*M1-成员撤销修订[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_9.getCancelRevisionObj(),"D1判断组织架构进入管理可用(公共)-M1-成员撤销修订-撤销修订不能为空",false);
      receptionServiceRes_18 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_9);
      
      
      receptionServiceRes_19 = receptionServiceRes_18;
//virtualUsage M1-成员变更记录  14049
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_20 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_10=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_10.setChangeRecordObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183853_1_14049
    }
  
    /*M1-成员变更记录[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_10.getChangeRecordObj(),"D1判断组织架构进入管理可用(公共)-M1-成员变更记录-变更记录不能为空",false);
      receptionServiceRes_20 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_10);
      
      
      receptionServiceRes_21 = receptionServiceRes_20;
//virtualUsage M1-成员锁定原因  14050
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_22 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_11=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_11.setLockReasonObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:183954_1_14050
    }
  
    /*M1-成员锁定原因[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_11.getLockReasonObj(),"D1判断组织架构进入管理可用(公共)-M1-成员锁定原因-锁定原因不能为空",false);
      receptionServiceRes_22 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_11);
      
      
      receptionServiceRes_23 = receptionServiceRes_22;
//virtualUsage M1-成员批次现状  14051
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_24 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_12=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_12.setBatchCurrentStatus(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:198886_1_14051
    }
  
    /*M1-成员批次现状[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_12.getBatchCurrentStatus(),"D1判断组织架构进入管理可用(公共)-M1-成员批次现状-批次现状不能为空",false);
      receptionServiceRes_24 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_12);
      
      
      receptionServiceRes_25 = receptionServiceRes_24;
//virtualUsage M1-成员首次管理操作  14053
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_26 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_13=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_13.setFirstOperation(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:199150_1_14053
    }
  
    /*M1-成员首次管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_13.getFirstOperation(),"D1判断组织架构进入管理可用(公共)-M1-成员首次管理操作-首次操作不能为空",false);
      receptionServiceRes_26 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_13);
      
      
      receptionServiceRes_27 = receptionServiceRes_26;
//virtualUsage M1-成员后续管理操作  14054
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_28 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_14=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_14.setTrailingOperation(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:199155_1_14054
    }
  
    /*M1-成员后续管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_14.getTrailingOperation(),"D1判断组织架构进入管理可用(公共)-M1-成员后续管理操作-后续操作不能为空",false);
      receptionServiceRes_28 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_14);
      
      
      receptionServiceRes_29 = receptionServiceRes_28;
//virtualUsage M1-成员混合管理操作  14055
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_30 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_15=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_15.setMixtureOperation(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:198885_1_14055
    }
  
    /*M1-成员混合管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_15.getMixtureOperation(),"D1判断组织架构进入管理可用(公共)-M1-成员混合管理操作-全批次操作不能为空",false);
      receptionServiceRes_30 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_15);
      
      
      receptionServiceRes_31 = receptionServiceRes_30;
//virtualUsage M1-部门开始管理  14061
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_32 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_16=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_16.setDeptStartMgt(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:245616_1_14061
    }
  
    /*M1-部门开始管理[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_16.getDeptStartMgt(),"D1判断组织架构进入管理可用(公共)-M1-部门开始管理-部门开始管理不能为空",false);
      receptionServiceRes_32 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_16);
      
      
      receptionServiceRes_33 = receptionServiceRes_32;
//virtualUsage M1-部门管理操作  14406
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_34 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_17=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_17.setDeptOperation(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:254943_1_14406
    }
  
    /*M1-部门管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_17.getDeptOperation(),"D1判断组织架构进入管理可用(公共)-M1-部门管理操作-部门管理操作不能为空",false);
      receptionServiceRes_34 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_17);
      
      
      receptionServiceRes_35 = receptionServiceRes_34;
//virtualUsage M1-部门维护完成  14062
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_36 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_18=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_18.setDeptPreserveAchieve(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:245614_1_14062
    }
  
    /*M1-部门维护完成[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_18.getDeptPreserveAchieve(),"D1判断组织架构进入管理可用(公共)-M1-部门维护完成-部门维护完成不能为空",false);
      receptionServiceRes_36 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_18);
      
      
      receptionServiceRes_37 = receptionServiceRes_36;
//virtualUsage M1-部门变更记录  14847
      //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_38 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_19=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_19.setDeptChangeRecordObj(receptionServiceRes.getOutputNum()!=null?String.valueOf(receptionServiceRes.getOutputNum()):"");//SimpleFieldAssign//sourceId:261687_1_14847
    }
  
    /*M1-部门变更记录[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_19.getDeptChangeRecordObj(),"D1判断组织架构进入管理可用(公共)-M1-部门变更记录-部门变更记录不能为空",false);
      receptionServiceRes_38 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_19);
      
      
      receptionServiceRes_39 = receptionServiceRes_38;
if((organization!= null&& organization.getCurrentManageObjectType() != null &&!(organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER"))&&organization!= null&& organization.getManageLockStatus() != null &&!(organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 值不等于空  and 1-3-12查询组织管理状态等信息.当前管理对象类型 不等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 值不等于空  and 1-3-12查询组织管理状态等信息.管理锁定状态 不等于 未锁定))  11912
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_40 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_20=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_20.setStartMgtObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:184161_1_11934
    }
  
    /*M1-成员开始管理[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_20.getStartMgtObj(),"D1判断组织架构进入管理可用(公共)-M1-成员开始管理-开始管理不能为空",false);
      receptionServiceRes_40 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_20);
      
      
      receptionServiceRes_7 = receptionServiceRes_40;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("UNMANNED_MGT")&&organization!= null&&  organization.getUsingLockStatus() !=null && organization.getUsingLockStatus().equals("UNLOCK"))&&(organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("COMMON_LOCK")||organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("AUTO_LOCK"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 无人管理 and 1-3-12查询组织管理状态等信息.使用锁定状态 等于 未锁定) and (1-3-12查询组织管理状态等信息.管理锁定状态 等于 普通锁定 or 1-3-12查询组织管理状态等信息.管理锁定状态 等于 自动锁定))  11973
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_41 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_21=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_21.setSuspendedObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183849_1_11975
    }
  
    /*M1-成员暂停对外使用[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_21.getSuspendedObj(),"D1判断组织架构进入管理可用(公共)-M1-成员暂停对外使用-暂停对外使用不能为空",false);
      receptionServiceRes_41 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_21);
      
      
      receptionServiceRes_9 = receptionServiceRes_41;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("UNMANNED_MGT"))&&(organization!= null&&  organization.getUsingLockStatus() !=null && organization.getUsingLockStatus().equals("COMMON_LOCK")||organization!= null&&  organization.getUsingLockStatus() !=null && organization.getUsingLockStatus().equals("AUTO_LOCK"))&&(organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("COMMON_LOCK")||organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("AUTO_LOCK"))) {
        //if(1-3-12查询组织管理状态等信息.当前管理对象类型 等于 无人管理 and (1-3-12查询组织管理状态等信息.使用锁定状态 等于 普通锁定 or 1-3-12查询组织管理状态等信息.使用锁定状态 等于 自动锁定) and (1-3-12查询组织管理状态等信息.管理锁定状态 等于 普通锁定 or 1-3-12查询组织管理状态等信息.管理锁定状态 等于 自动锁定))  11972
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_42 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_22=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_22.setRestoreObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183851_1_11976
    }
  
    /*M1-成员恢复对外使用[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_22.getRestoreObj(),"D1判断组织架构进入管理可用(公共)-M1-成员恢复对外使用-恢复对外使用不能为空",false);
      receptionServiceRes_42 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_22);
      
      
      receptionServiceRes_11 = receptionServiceRes_42;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")&&statusCheckItem!= null&&  statusCheckItem.getIsComplete() !=null && statusCheckItem.getIsComplete().equals("TRUE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11971
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_43 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_23=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_23.setReleaseEffectObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183741_1_11979
    }
  
    /*M1-成员发布生效[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_23.getReleaseEffectObj(),"D1判断组织架构进入管理可用(公共)-M1-成员发布生效-发布生效不能为空",false);
      receptionServiceRes_43 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_23);
      
      
      receptionServiceRes_13 = receptionServiceRes_43;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")&&statusCheckItem!= null&&  statusCheckItem.getIsComplete() !=null && statusCheckItem.getIsComplete().equals("TRUE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11970
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_44 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_24=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_24.setCancelSetCompleteObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183747_1_11982
    }
  
    /*M1-成员取消设置完成[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_24.getCancelSetCompleteObj(),"D1判断组织架构进入管理可用(公共)-M1-成员取消设置完成-取消设置完成不能为空",false);
      receptionServiceRes_44 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_24);
      
      
      receptionServiceRes_15 = receptionServiceRes_44;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")&&statusCheckItem!= null&&  statusCheckItem.getIsComplete() !=null && statusCheckItem.getIsComplete().equals("FALSE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11968
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_45 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_25=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_25.setSetCompleteObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183745_1_11983
    }
  
    /*M1-成员确认设置完成[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_25.getSetCompleteObj(),"D1判断组织架构进入管理可用(公共)-M1-成员确认设置完成-确认设置完成不能为空",false);
      receptionServiceRes_45 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_25);
      
      
      receptionServiceRes_17 = receptionServiceRes_45;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")&&statusCheckItem!= null&&  statusCheckItem.getIsComplete() !=null && statusCheckItem.getIsComplete().equals("FALSE")&&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("FALSE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11967
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_46 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_26=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_26.setCancelRevisionObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183744_1_11989
    }
  
    /*M1-成员撤销修订[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_26.getCancelRevisionObj(),"D1判断组织架构进入管理可用(公共)-M1-成员撤销修订-撤销修订不能为空",false);
      receptionServiceRes_46 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_26);
      
      
      receptionServiceRes_19 = receptionServiceRes_46;
      }
if((batch != null &&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("FALSE"))) {
        //if((1-1-01查询当前最新批次信息.出参 值不等于空  and 1-1-01查询当前最新批次信息.是否首次批次 等于 否))  11988
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_47 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_27=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_27.setChangeRecordObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183853_1_11990
    }
  
    /*M1-成员变更记录[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_27.getChangeRecordObj(),"D1判断组织架构进入管理可用(公共)-M1-成员变更记录-变更记录不能为空",false);
      receptionServiceRes_47 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_27);
      
      
      receptionServiceRes_21 = receptionServiceRes_47;
      }
if((!(organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER"))&&!(organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK"))&&!(organization!= null&&  organization.getUsingLockStatus() !=null && organization.getUsingLockStatus().equals("UNLOCK")))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 不等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 不等于 未锁定 and 1-3-12查询组织管理状态等信息.使用锁定状态 不等于 未锁定))  11987
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_48 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_28=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_28.setLockReasonObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:183954_1_11991
    }
  
    /*M1-成员锁定原因[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_28.getLockReasonObj(),"D1判断组织架构进入管理可用(公共)-M1-成员锁定原因-锁定原因不能为空",false);
      receptionServiceRes_48 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_28);
      
      
      receptionServiceRes_23 = receptionServiceRes_48;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")&&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("TRUE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-01查询当前最新批次信息.是否首次批次 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11986
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_49 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_29=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_29.setBatchCurrentStatus(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:198886_1_11993
    }
  
    /*M1-成员批次现状[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_29.getBatchCurrentStatus(),"D1判断组织架构进入管理可用(公共)-M1-成员批次现状-批次现状不能为空",false);
      receptionServiceRes_49 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_29);
      
      
      receptionServiceRes_25 = receptionServiceRes_49;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")&&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("FALSE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11985
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_50 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_30=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_30.setBatchCurrentStatus(receptionServiceRes_4.getOutputNum()!=null?String.valueOf(receptionServiceRes_4.getOutputNum()):"");//SimpleFieldAssign//sourceId:198886_1_14619
    }
  
    /*M1-成员批次现状[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_30.getBatchCurrentStatus(),"D1判断组织架构进入管理可用(公共)-M1-成员批次现状-批次现状不能为空",false);
      receptionServiceRes_50 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_30);
      
      
      receptionServiceRes_25 = receptionServiceRes_50;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&statusCheckItem!= null&&  statusCheckItem.getIsComplete() !=null && statusCheckItem.getIsComplete().equals("FALSE")&&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("TRUE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.是否首次批次 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定))  12681
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_51 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_31=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_31.setFirstOperation(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:199150_1_12691
    }
  
    /*M1-成员首次管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_31.getFirstOperation(),"D1判断组织架构进入管理可用(公共)-M1-成员首次管理操作-首次操作不能为空",false);
      receptionServiceRes_51 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_31);
      
      
      receptionServiceRes_27 = receptionServiceRes_51;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&statusCheckItem!= null&&  statusCheckItem.getIsComplete() !=null && statusCheckItem.getIsComplete().equals("FALSE")&&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("FALSE")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定))  12679
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_52 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_32=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_32.setTrailingOperation(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:199155_1_12692
    }
  
    /*M1-成员后续管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_32.getTrailingOperation(),"D1判断组织架构进入管理可用(公共)-M1-成员后续管理操作-后续操作不能为空",false);
      receptionServiceRes_52 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_32);
      
      
      receptionServiceRes_29 = receptionServiceRes_52;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&statusCheckItem!= null&&  statusCheckItem.getIsComplete() !=null && statusCheckItem.getIsComplete().equals("FALSE")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK"))&&(batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定) and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑)  12694
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_53 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_33=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_33.setMixtureOperation(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:198885_1_12695
    }
  
    /*M1-成员混合管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_33.getMixtureOperation(),"D1判断组织架构进入管理可用(公共)-M1-成员混合管理操作-全批次操作不能为空",false);
      receptionServiceRes_53 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_33);
      
      
      receptionServiceRes_31 = receptionServiceRes_53;
      }
if((organization!= null&& organization.getManageLockStatus() != null &&organization!= null&& organization.getCurrentManageObjectType() != null &&!(organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("DEPTMENT")))) {
        //if((1-3-12查询组织管理状态等信息.管理锁定状态 值不等于空  and 1-3-12查询组织管理状态等信息.当前管理对象类型 值不等于空  and 1-3-12查询组织管理状态等信息.当前管理对象类型 不等于 部门))  14059
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_54 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_34=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_34.setDeptStartMgt(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:245616_1_14063
    }
  
    /*M1-部门开始管理[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_34.getDeptStartMgt(),"D1判断组织架构进入管理可用(公共)-M1-部门开始管理-部门开始管理不能为空",false);
      receptionServiceRes_54 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_34);
      
      
      receptionServiceRes_33 = receptionServiceRes_54;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("DEPTMENT")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK"))) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 部门 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定))  14398
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_55 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_35=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_35.setDeptOperation(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:254943_1_14400
    }
  
    /*M1-部门管理操作[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_35.getDeptOperation(),"D1判断组织架构进入管理可用(公共)-M1-部门管理操作-部门管理操作不能为空",false);
      receptionServiceRes_55 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_35);
      
      
      receptionServiceRes_35 = receptionServiceRes_55;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("DEPTMENT")&&organization!= null&&  organization.getManageLockStatus() !=null && organization.getManageLockStatus().equals("UNLOCK")&&listDept_2!= null&&  listDept_2 !=null && listDept_2.size()==0)) {
        //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 部门 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-3-09查询部门列表（用于判断部门维护完成是否可用）.部门列表数据集条数 等于 0))  14058
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_56 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_36=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_36.setDeptPreserveAchieve(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:245614_1_14064
    }
  
    /*M1-部门维护完成[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_36.getDeptPreserveAchieve(),"D1判断组织架构进入管理可用(公共)-M1-部门维护完成-部门维护完成不能为空",false);
      receptionServiceRes_56 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_36);
      
      
      receptionServiceRes_37 = receptionServiceRes_56;
      }
if((organization!= null&& organization.getCurrentManageObjectType() != null )) {
        //if(1-3-12查询组织管理状态等信息.当前管理对象类型 值不等于空 )  14849
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_57 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_37=new QueryReceiveFieldDetailReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_37.setDeptChangeRecordObj(receptionServiceRes_2.getOutputNum()!=null?String.valueOf(receptionServiceRes_2.getOutputNum()):"");//SimpleFieldAssign//sourceId:261687_1_14850
    }
  
    /*M1-部门变更记录[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_37.getDeptChangeRecordObj(),"D1判断组织架构进入管理可用(公共)-M1-部门变更记录-部门变更记录不能为空",false);
      receptionServiceRes_57 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_37);
      
      
      receptionServiceRes_39 = receptionServiceRes_57;
      }
if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("UNMANNED_MGT"))) {
        //if(1-3-12查询组织管理状态等信息.当前管理对象类型 等于 无人管理)  14859
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_58 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_38=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_38.setMemtMgtSence("ORG_CAN_MGT_SEN");//sourceId:262133_1_14868
  
    /*M1-组织架构可以开始管理场景[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_38.getMemtMgtSence(),"D1判断组织架构进入管理可用(公共)-M1-组织架构可以开始管理场景-组织架构管理场景不能为空",false);
      receptionServiceRes_58 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_38);
      
      
      receptionServiceRes_59 = receptionServiceRes_58;
      }
else if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING")&&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("TRUE"))){
       //elseif((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-1-01查询当前最新批次信息.是否首次批次 等于 是))  14861
      
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_60 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_39=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_39.setMemtMgtSence("MEM_FIR_BATCH_MGT_SEN");//sourceId:262401_1_14869
  
    /*M1-成员首次管理场景[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_39.getMemtMgtSence(),"D1判断组织架构进入管理可用(公共)-M1-成员首次管理场景-组织架构管理场景不能为空",false);
      receptionServiceRes_60 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_39);
      
      
      receptionServiceRes_61 = receptionServiceRes_60;
    }
else if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("MEMBER")&&batch!= null&&  batch.getSubjectLifeCycle() !=null && batch.getSubjectLifeCycle().equals("EDITING")&&batch!= null&&  batch.getIsFirst() !=null && batch.getIsFirst().equals("FALSE"))){
       //elseif((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否))  14862
      
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_62 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_40=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_40.setMemtMgtSence("MEM_SUB_BATCH_MGT_SEN");//sourceId:262426_1_14870
  
    /*M1-成员后续管理场景[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_40.getMemtMgtSence(),"D1判断组织架构进入管理可用(公共)-M1-成员后续管理场景-组织架构管理场景不能为空",false);
      receptionServiceRes_62 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_40);
      
      
      receptionServiceRes_63 = receptionServiceRes_62;
    }
else if((organization!= null&&  organization.getCurrentManageObjectType() !=null && organization.getCurrentManageObjectType().equals("DEPTMENT"))){
       //elseif(1-3-12查询组织管理状态等信息.当前管理对象类型 等于 部门)  14863
      
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_64 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_41=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_41.setMemtMgtSence("DEPT_MGT_SEN");//sourceId:262427_1_14871
  
    /*M1-部门管理场景[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_41.getMemtMgtSence(),"D1判断组织架构进入管理可用(公共)-M1-部门管理场景-组织架构管理场景不能为空",false);
      receptionServiceRes_64 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_41);
      
      
      receptionServiceRes_65 = receptionServiceRes_64;
    }
else if((organization!= null&& organization.getCurrentManageObjectType() == null )){
       //elseif(1-3-12查询组织管理状态等信息.当前管理对象类型 值等于空 )  14864
      
//异常结束 14873
      throw new BizException("10300093","对不起，当前谁在管理出现未知异常，请联系管理员。~",false);
    }
else if((organization!= null&& organization.getManageLockStatus() == null )){
       //elseif(1-3-12查询组织管理状态等信息.管理锁定状态 值等于空 )  14865
      
//异常结束 14874
      throw new BizException("10300095","对不起！管理状态未知异常，请联系管理员~",false);
    }
else if((organization!= null&& organization.getUsingLockStatus() == null )){
       //elseif(1-3-12查询组织管理状态等信息.使用锁定状态 值等于空 )  14866
      
//异常结束 14875
      throw new BizException("10300095","对不起！管理状态未知异常，请联系管理员~",false);
    }
else if((statusCheckItem == null ||statusCheckItem!= null&& statusCheckItem.getIsComplete() == null )){
       //elseif((1-1-22查询组织架构管理检查项状态.出参 值等于空  or 1-1-22查询组织架构管理检查项状态.是否已完成 值等于空 ))  14872
      
//异常结束 14876
      throw new BizException("10300107","对不起，管理完成状态出现未知异常，请联系管理员~。",false);
    }
//processBranchName:正常结束 ,processBranchId:11996
        
JudgeOrgStructureMgtUsableComRespDto retData = new JudgeOrgStructureMgtUsableComRespDto();
  if(batch_1!=null){
      retData.setBatchId(batch_1.getBatchId());//SimpleFieldAssign//sourceId:184256_1
    }
if(receptionServiceRes_25!=null){
      retData.setBatchCurrentStatus(receptionServiceRes_25.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:184218_1
retData.setBatchCurrentStatus(receptionServiceRes_25.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:184218_1
    }
if(receptionServiceRes_7!=null){
      retData.setStartMgtObj(receptionServiceRes_7.getStartMgtObj());//SimpleFieldAssign//sourceId:184221_1
    }
if(receptionServiceRes_9!=null){
      retData.setSuspendedObj(receptionServiceRes_9.getSuspendedObj());//SimpleFieldAssign//sourceId:184212_1
    }
if(receptionServiceRes_11!=null){
      retData.setRestoreObj(receptionServiceRes_11.getRestoreObj());//SimpleFieldAssign//sourceId:184213_1
    }
if(receptionServiceRes_23!=null){
      retData.setLockReasonObj(receptionServiceRes_23.getLockReasonObj());//SimpleFieldAssign//sourceId:184217_1
    }
if(receptionServiceRes_13!=null){
      retData.setReleaseEffectObj(receptionServiceRes_13.getReleaseEffectObj());//SimpleFieldAssign//sourceId:184216_1
    }
if(receptionServiceRes_15!=null){
      retData.setCancelSetCompleteObj(receptionServiceRes_15.getCancelSetCompleteObj());//SimpleFieldAssign//sourceId:184211_1
    }
if(receptionServiceRes_17!=null){
      retData.setSetCompleteObj(receptionServiceRes_17.getSetCompleteObj());//SimpleFieldAssign//sourceId:184210_1
    }
if(receptionServiceRes_19!=null){
      retData.setCancelRevisionObj(receptionServiceRes_19.getCancelRevisionObj());//SimpleFieldAssign//sourceId:184215_1
    }
if(receptionServiceRes_21!=null){
      retData.setChangeRecordObj(receptionServiceRes_21.getChangeRecordObj());//SimpleFieldAssign//sourceId:184214_1
    }
if(receptionServiceRes_27!=null){
      retData.setFirstOperation(receptionServiceRes_27.getFirstOperation());//SimpleFieldAssign//sourceId:199335_1
    }
if(receptionServiceRes_29!=null){
      retData.setTrailingOperation(receptionServiceRes_29.getTrailingOperation());//SimpleFieldAssign//sourceId:199334_1
    }
if(receptionServiceRes_31!=null){
      retData.setMixtureOperation(receptionServiceRes_31.getMixtureOperation());//SimpleFieldAssign//sourceId:199333_1
    }
if(receptionServiceRes_33!=null){
      retData.setDeptStartMgt(receptionServiceRes_33.getDeptStartMgt());//SimpleFieldAssign//sourceId:245619_1
    }
if(receptionServiceRes_35!=null){
      retData.setDeptOperation(receptionServiceRes_35.getDeptOperation());//SimpleFieldAssign//sourceId:254950_1
    }
if(receptionServiceRes_37!=null){
      retData.setDeptPreserveAchieve(receptionServiceRes_37.getDeptPreserveAchieve());//SimpleFieldAssign//sourceId:245618_1
    }
if(receptionServiceRes_39!=null){
      retData.setDeptChangeRecordObj(receptionServiceRes_39.getDeptChangeRecordObj());//SimpleFieldAssign//sourceId:261689_1
    }
if(receptionServiceRes_59!=null){
      retData.setMemtMgtSence(receptionServiceRes_59.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
    }
if(receptionServiceRes_61!=null){
      retData.setMemtMgtSence(receptionServiceRes_61.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
    }
if(receptionServiceRes_63!=null){
      retData.setMemtMgtSence(receptionServiceRes_63.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
    }
if(receptionServiceRes_65!=null){
      retData.setMemtMgtSence(receptionServiceRes_65.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
    }
  

  
  
return retData;
  }
/**
   * 1111D1-1发布底层框架服务批次	[921]
   * gen by moon at 10/2/2022, 7:50:40 AM
   */
  @Trace(operationName = "1111D1-1发布底层框架服务批次	")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReleaseBaseBatchRespDto releaseBaseBatch(ReleaseBaseBatchReqDto reqDto){


      //virtualUsage 通过批次ID，查出批次ID对应的用途类型编码、归属对象ID  1511
      Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  if(reqDto!=null){
      queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:19801_1_1511
    }

    /*通过批次ID，查出批次ID对应的用途类型编码、归属对象ID[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getBatchId(),"1111D1-1发布底层框架服务批次	-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-批次ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getSpaceId(),"1111D1-1发布底层框架服务批次	-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于空间ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getAppId(),"1111D1-1发布底层框架服务批次	-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于联盟应用ID不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);



//virtualUsage 通过用途类型编码、归属对象ID查询出当前有效的批次ID  1512
      Batch batch_2 = null;
    if(batch !=null){
          QueryBaseBatchDetailReq queryBaseBatchDetailReq_1=new QueryBaseBatchDetailReq();
  queryBaseBatchDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:17506_1_1512
if(batch!=null){
      queryBaseBatchDetailReq_1.setPurposeTypeCode(batch.getPurposeTypeCode());//SimpleFieldAssign//sourceId:17500_1_1512
queryBaseBatchDetailReq_1.setAscriptionObjectId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:17501_1_1512
    }

    /*通过用途类型编码、归属对象ID查询出当前有效的批次ID[44]   */
    Assert.isNull(queryBaseBatchDetailReq_1.getPurposeTypeCode(),"1111D1-1发布底层框架服务批次	-通过用途类型编码、归属对象ID查询出当前有效的批次ID-用途类型编码不能为空",false);
Assert.isNull(queryBaseBatchDetailReq_1.getAscriptionObjectId(),"1111D1-1发布底层框架服务批次	-通过用途类型编码、归属对象ID查询出当前有效的批次ID-归属对象ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq_1.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-通过用途类型编码、归属对象ID查询出当前有效的批次ID-主体生命周期不能为空",false);
      batch_2 = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq_1);



           }
//virtualUsage 修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是  1513
      boolean bOOLEAN ;
    if(batch_2 !=null){
          Batch batch_4=new Batch();
  batch_4.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:17497_1_1513
batch_4.setSubjectLifeCycle("ARCHIVING");//sourceId:17498_1_1513
batch_4.setIsArchive("TRUE");//sourceId:17516_1_1513
batch_4.setIsEditing("FALSE");//sourceId:48237_1_1513
if(batch_2!=null){
      batch_4.setBatchId(batch_2.getBatchId());//SimpleFieldAssign//sourceId:17493_1_1513
    }

    /*修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是[42]   */
    Assert.isNull(batch_4.getBatchId(),"1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-批次ID不能为空",false);
Assert.isNull(batch_4.getBatchEndTime(),"1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-批次结束时间不能为空",false);
Assert.isNull(batch_4.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-主体生命周期不能为空",false);
Assert.isNull(batch_4.getIsArchive(),"1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-是否存档不能为空",false);
Assert.isNull(batch_4.getIsEditing(),"1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-是否未来不能为空",false);
      bOOLEAN = mBatchService.updateBaseBatch(batch_4);



           }
//virtualUsage 修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间  1514
      boolean bOOLEAN_1 ;
    Batch batch_5=new Batch();
  batch_5.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:17541_1_1514
batch_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:17543_1_1514
batch_5.setIsEditing("FALSE");//sourceId:149690_1_1514
if(reqDto!=null){
      batch_5.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:17538_1_1514
    }

    /*修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间[42]   */
    Assert.isNull(batch_5.getBatchId(),"1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-批次ID不能为空",false);
Assert.isNull(batch_5.getBatchStartTime(),"1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-批次开始时间不能为空",false);
Assert.isNull(batch_5.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-主体生命周期不能为空",false);
Assert.isNull(batch_5.getIsEditing(),"1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-是否未来不能为空",false);
      bOOLEAN_1 = mBatchService.updateBaseBatch(batch_5);



//virtualUsage D2-3查询组织架构模式配置  5666
      QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
    QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto=new QueryItemMatchResultToAnswerDetailComReqDto();
  queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105255_1_5666
queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:105256_1_5666
queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105257_1_5666

    /*D2-3查询组织架构模式配置[3094]   */
    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(),"1111D1-1发布底层框架服务批次	-D2-3查询组织架构模式配置-配置项标识不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(),"1111D1-1发布底层框架服务批次	-D2-3查询组织架构模式配置-答案归属对象类型不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"1111D1-1发布底层框架服务批次	-D2-3查询组织架构模式配置-答案归属对象ID不能为空",false);
      queryItemMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData();



//virtualUsage 组织架构发布中临时自动锁定-暂停对外使用  4347
      boolean bOOLEAN_2 ;
    if(batch !=null){
          Organization organization=new Organization();
  organization.setUsingLockStatus("AUTO_LOCK");//sourceId:48254_1_4347
organization.setReasonOfUsingLock("组织架构正在维护，暂停使用，请耐心等待～");//CUSTOM_CONVENTION//sourceId:172601_1_4347
if(batch!=null){
      organization.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48251_1_4347
    }

    /*组织架构发布中临时自动锁定-暂停对外使用[197]   */
    Assert.isNull(organization.getOrganizationId(),"1111D1-1发布底层框架服务批次	-组织架构发布中临时自动锁定-暂停对外使用-组织ID不能为空",false);
Assert.isNull(organization.getUsingLockStatus(),"1111D1-1发布底层框架服务批次	-组织架构发布中临时自动锁定-暂停对外使用-使用锁定状态不能为空",false);
Assert.isNull(organization.getReasonOfUsingLock(),"1111D1-1发布底层框架服务批次	-组织架构发布中临时自动锁定-暂停对外使用-使用锁定原因不能为空",false);
      bOOLEAN_2 = mOrganizationService.updateOrg(organization);



           }
//virtualUsage 查询本次新增的就职记录列表  1517
      List<InductionRecord> listInductionRecord =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq=new QueryInductionRecordListReq();
  queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:48328_1_1517
if(batch!=null){
      queryInductionRecordListReq.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48325_1_1517
    }
  
    /*查询本次新增的就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq.getOrganizationId(),"1111D1-1发布底层框架服务批次	-查询本次新增的就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq.getUpdateStatus(),"1111D1-1发布底层框架服务批次	-查询本次新增的就职记录列表-批次下更新状态不能为空",false);
      listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);



           }
//virtualUsage 查询新增组织就职记录列表  1579
      List<InductionRecord> listInductionRecord_2 =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq_1=new QueryInductionRecordListReq();
  queryInductionRecordListReq_1.setInductionUnitTypeCode("ORG");//sourceId:49231_1_1579
queryInductionRecordListReq_1.setUpdateStatus("NEW");//sourceId:49234_1_1579
if(batch!=null){
      queryInductionRecordListReq_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:49232_1_1579
    }

    /*查询新增组织就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_1.getOrganizationId(),"1111D1-1发布底层框架服务批次	-查询新增组织就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_1.getInductionUnitTypeCode(),"1111D1-1发布底层框架服务批次	-查询新增组织就职记录列表-就职单位类型实例不能为空",false);
Assert.isNull(queryInductionRecordListReq_1.getUpdateStatus(),"1111D1-1发布底层框架服务批次	-查询新增组织就职记录列表-批次下更新状态不能为空",false);
      listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);



           }
//virtualUsage 查询新增部门就职记录列表  1580
      List<InductionRecord> listInductionRecord_4 =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq_2=new QueryInductionRecordListReq();
  queryInductionRecordListReq_2.setInductionUnitTypeCode("DEPT");//sourceId:49235_1_1580
queryInductionRecordListReq_2.setUpdateStatus("NEW");//sourceId:49237_1_1580
if(batch!=null){
      queryInductionRecordListReq_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:49236_1_1580
    }

    /*查询新增部门就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_2.getOrganizationId(),"1111D1-1发布底层框架服务批次	-查询新增部门就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_2.getInductionUnitTypeCode(),"1111D1-1发布底层框架服务批次	-查询新增部门就职记录列表-就职单位类型实例不能为空",false);
Assert.isNull(queryInductionRecordListReq_2.getUpdateStatus(),"1111D1-1发布底层框架服务批次	-查询新增部门就职记录列表-批次下更新状态不能为空",false);
      listInductionRecord_4 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2);



           }
//virtualUsage 查询本次修订的就职记录列表  1518
      List<InductionRecord> listInductionRecord_6 =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq_3=new QueryInductionRecordListReq();
  queryInductionRecordListReq_3.setUpdateStatus("REVISION");//sourceId:48362_1_1518
if(batch!=null){
      queryInductionRecordListReq_3.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48361_1_1518
    }

    /*查询本次修订的就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_3.getOrganizationId(),"1111D1-1发布底层框架服务批次	-查询本次修订的就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_3.getUpdateStatus(),"1111D1-1发布底层框架服务批次	-查询本次修订的就职记录列表-批次下更新状态不能为空",false);
      listInductionRecord_6 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_3);



           }
//virtualUsage 查询本次存档的就职记录列表  1560
      List<InductionRecord> listInductionRecord_8 =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq_4=new QueryInductionRecordListReq();
  queryInductionRecordListReq_4.setUpdateStatus("ARCHIVE");//sourceId:48397_1_1560
if(batch!=null){
      queryInductionRecordListReq_4.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48396_1_1560
    }

    /*查询本次存档的就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq_4.getOrganizationId(),"1111D1-1发布底层框架服务批次	-查询本次存档的就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_4.getUpdateStatus(),"1111D1-1发布底层框架服务批次	-查询本次存档的就职记录列表-批次下更新状态不能为空",false);
      listInductionRecord_8 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_4);



           }
//virtualUsage 1-1-02批量查询变更字段列表ByIds  1561
      List<ChangeColumn> listChangeColumn =new ArrayList<>();
    if(listInductionRecord_6 !=null&& listInductionRecord_6.size()>0 ){
          BatchQueryBaseChangeColListByIdsReq batchQueryBaseChangeColListByIdsReq=new BatchQueryBaseChangeColListByIdsReq();
  batchQueryBaseChangeColListByIdsReq.setChangeEntityId(listInductionRecord_6.stream().map(item->item.getInductionRecordId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:48474_1_1561
batchQueryBaseChangeColListByIdsReq.setTableTypeCode("OMS_ORG_INDUCTION_RECORD");//sourceId:48473_1_1561
batchQueryBaseChangeColListByIdsReq.setIsInproperties("TRUE");//sourceId:48482_1_1561
batchQueryBaseChangeColListByIdsReq.setSubjectLifeCycle("EDITING");//sourceId:48477_1_1561
batchQueryBaseChangeColListByIdsReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:48518_1_1561

    /*1-1-02批量查询变更字段列表ByIds[310]   */
    Assert.isNull(batchQueryBaseChangeColListByIdsReq.getTableTypeCode(),"1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-内容表类型编码不能为空",false);
Assert.isNull(batchQueryBaseChangeColListByIdsReq.getIsInproperties(),"1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-是否内部属性不能为空",false);
Assert.isNull(batchQueryBaseChangeColListByIdsReq.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-主体生命周期不能为空",false);
Assert.isNull(batchQueryBaseChangeColListByIdsReq.getSpaceId(),"1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.batchQueryBaseChangeColListByIds(batchQueryBaseChangeColListByIdsReq);



           }
//virtualUsage M合并就职记录变更字段列表  1520
      //ModelCode: mergeChangeColumnList
        MergeChangeColumnIrListRespDto mergeChangeColumnListRes = null;
    if(listInductionRecord_6 !=null&& listInductionRecord_6.size()>0 &&listChangeColumn !=null&& listChangeColumn.size()>0 ){
          MergeChangeColumnIrListReqDto mergeChangeColumnListReq=new MergeChangeColumnIrListReqDto();
  mergeChangeColumnListReq.setOrgInductionRecordList(listInductionRecord_6.stream().map(item -> BeanUtil.toBean(item, OrgInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:48418_1_1520
mergeChangeColumnListReq.setMergeInductionRecordList(//objList-to-objLists
        listChangeColumn.stream().map(item -> {
      MergeInductionRecordDto elm = new MergeInductionRecordDto();
      elm.setInductionRecordId(item.getEntityId());//SimpleFieldAssign//sourceId:23703_2_1520
elm.setDirectorInductionRecordId(item.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:23702_2_1520
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:48419_1_1520

    /*M合并就职记录变更字段列表[1646]  通过合并标识，将第二个数据集的数据覆盖第一个数据集数据 */

      mergeChangeColumnListRes = nbBatch.mergeChangeColumnIrList(mergeChangeColumnListReq);



           }
//virtualUsage 1-1-02批量改底层变更字段  1562
      boolean bOOLEAN_3 ;
    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
          List<ChangeColumn> listChangeColumn_2=new ArrayList<>();
  listChangeColumn_2 = //objList-to-objLists
        listChangeColumn.stream().map(item -> {
      ChangeColumn elm = new ChangeColumn();
      elm.setChangeColumnId(item.getChangeColumnId());//SimpleFieldAssign//sourceId:69576_2_1562
elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:69581_2_1562
elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:69579_2_1562
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:152018_1_1562

    /*1-1-02批量改底层变更字段[1630]   */

      bOOLEAN_3 = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_2);



           }
//virtualUsage 批量改本次新增就职记录  1563
      boolean bOOLEAN_4 ;
    if(listInductionRecord !=null&& listInductionRecord.size()>0 ){
          List<InductionRecord> listInductionRecord_10=new ArrayList<>();
  listInductionRecord_10 = //objList-to-objLists
        listInductionRecord.stream().map(item -> {
      InductionRecord elm = new InductionRecord();
      elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23975_2_1563
elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:23977_2_1563
elm.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:23978_2_1563
elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:23979_2_1563
elm.setIsArchive("FALSE");//sourceId:23980_2_1563
elm.setArchivngType("NOT_ARCHIVE");//sourceId:23981_2_1563
elm.setIsEditing("TRUE");//sourceId:23982_2_1563
elm.setIsUpdate("FALSE");//sourceId:23983_2_1563
elm.setUpdateStatus("UNCHANGED");//sourceId:23984_2_1563
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48695_1_1563

    /*批量改本次新增就职记录[1647]   */

      bOOLEAN_4 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_10);



           }
//virtualUsage 批量改就职记录状态（重置本次修订）  1522
      boolean bOOLEAN_5 ;
    List<InductionRecord> listInductionRecord_11=new ArrayList<>();
  if(mergeChangeColumnListRes!=null){
      listInductionRecord_11 = //objList-to-objLists
        mergeChangeColumnListRes.getOrgInductionRecordList().stream().map(item -> {
      InductionRecord elm = new InductionRecord();
      elm.setIsUpdate("FALSE");//sourceId:23736_2_1522
elm.setUpdateStatus("UNCHANGED");//sourceId:23737_2_1522
if(item!=null){
      elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23728_2_1522
elm.setDirectorInductionRecordId(item.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:23729_2_1522
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48423_1_1522
    }

    /*批量改就职记录状态（重置本次修订）[1647]   */

      bOOLEAN_5 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_11);



//virtualUsage 批量改就职记录状态为历史存档  1523
      boolean bOOLEAN_6 ;
    if(listInductionRecord_8 !=null&& listInductionRecord_8.size()>0 ){
          List<InductionRecord> listInductionRecord_12=new ArrayList<>();
  listInductionRecord_12 = //objList-to-objLists
        listInductionRecord_8.stream().map(item -> {
      InductionRecord elm = new InductionRecord();
      elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23738_2_1523
elm.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:23741_2_1523
elm.setSubjectLifeCycle("ARCHIVING");//sourceId:23742_2_1523
elm.setIsArchive("TRUE");//sourceId:23743_2_1523
elm.setArchivngType("ARCHIVED");//sourceId:23744_2_1523
elm.setIsEditing("FALSE");//sourceId:23745_2_1523
elm.setIsUpdate("FALSE");//sourceId:23746_2_1523
elm.setUpdateStatus("UNCHANGED");//sourceId:23747_2_1523
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48424_1_1523

    /*批量改就职记录状态为历史存档[1647]   */

      bOOLEAN_6 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_12);



           }
//virtualUsage 查询存档就职记录的分配权限  1524
      List<PrivacyDistribution> listPrivacyDistribution =new ArrayList<>();
    if(listInductionRecord_8 !=null&& listInductionRecord_8.size()>0 ){
          BatchQueryTributPowerListReq batchQueryTributPowerListReq=new BatchQueryTributPowerListReq();
  batchQueryTributPowerListReq.setTributPowerList(listInductionRecord_8.stream().map(item->item.getInductionRecordId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:48426_1_1524
batchQueryTributPowerListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:48428_1_1524
batchQueryTributPowerListReq.setTypeCode("PERSONAL_DEPARTMENT");//sourceId:48425_1_1524

    /*查询存档就职记录的分配权限[702]   */
    Assert.isNull(batchQueryTributPowerListReq.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-查询存档就职记录的分配权限-主体生命周期不能为空",false);
Assert.isNull(batchQueryTributPowerListReq.getTypeCode(),"1111D1-1发布底层框架服务批次	-查询存档就职记录的分配权限-分配对象类型编码不能为空",false);
      listPrivacyDistribution = mPrivacyDistributionService.batchQueryTributPowerList(batchQueryTributPowerListReq);



           }
//virtualUsage 批量存档就职记录的分配权限  1525
      boolean bOOLEAN_7 ;
    if(listPrivacyDistribution !=null&& listPrivacyDistribution.size()>0 ){
          List<PrivacyDistribution> listPrivacyDistribution_2=new ArrayList<>();
  listPrivacyDistribution_2 = //objList-to-objLists
        listPrivacyDistribution.stream().map(item -> {
      PrivacyDistribution elm = new PrivacyDistribution();
      elm.setPrivacyDistributionId(item.getPrivacyDistributionId());//SimpleFieldAssign//sourceId:23752_2_1525
elm.setSubjectLifeCycle("ARCHIVING");//sourceId:24026_2_1525
elm.setIsArchive("TRUE");//sourceId:24027_2_1525
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48429_1_1525

    /*批量存档就职记录的分配权限[1554]   */

      bOOLEAN_7 = mPrivacyDistributionService.batchUpdateTributPower(listPrivacyDistribution_2);



           }
//virtualUsage D1-1修改检查项状态(公共)  8670
      UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
    if(batch !=null){
          UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto=new UpdateCheckItemStatComReqDto();
  updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144881_1_8670
updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144882_1_8670
updateCheckItemStatComReqDto.setIsComplete("TRUE");//sourceId:144880_1_8670
if(batch!=null){
      updateCheckItemStatComReqDto.setEntityId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:144883_1_8670
    }

    /*D1-1修改检查项状态(公共)[947]   */
    Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(),"1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(),"1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getEntityId(),"1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(),"1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-是否已完成不能为空",false);
      updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);



           }
//virtualUsage M-循环存档部门职务（特殊方法）  2138
      //ModelCode: circulationCollections
        for (InductionRecord circulationCollectionsRes: listInductionRecord_8){

//virtualUsage 查询部门职务关系ID下是否还有就职记录  2139
      List<InductionRecord> listInductionRecord_13 =new ArrayList<>();
    QueryInductionRecordListReq queryInductionRecordListReq_5=new QueryInductionRecordListReq();
  queryInductionRecordListReq_5.setIsArchive("FALSE");//sourceId:55559_1_2139
if(circulationCollectionsRes!=null){
      queryInductionRecordListReq_5.setDeptPositionRelationshipId(circulationCollectionsRes.getDeptPositionRelationshipId());//SimpleFieldAssign//sourceId:55558_1_2139
    }

    /*查询部门职务关系ID下是否还有就职记录[166]   */
    Assert.isNull(queryInductionRecordListReq_5.getDeptPositionRelationshipId(),"1111D1-1发布底层框架服务批次	-查询部门职务关系ID下是否还有就职记录-冗余部门职务关系ID不能为空",false);
Assert.isNull(queryInductionRecordListReq_5.getIsArchive(),"1111D1-1发布底层框架服务批次	-查询部门职务关系ID下是否还有就职记录-是否存档不能为空",false);
      listInductionRecord_13 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_5);



//virtualUsage 查询职务是否存档  2140
      Position position = null;
    QueryPositionDetailReq queryPositionDetailReq=new QueryPositionDetailReq();
  queryPositionDetailReq.setSubjectLifeCycle("ARCHIVING");//sourceId:55577_1_2140
if(circulationCollectionsRes!=null){
      queryPositionDetailReq.setPositionId(circulationCollectionsRes.getPositionId());//SimpleFieldAssign//sourceId:55560_1_2140
    }

    /*查询职务是否存档[146]   */
    Assert.isNull(queryPositionDetailReq.getPositionId(),"1111D1-1发布底层框架服务批次	-查询职务是否存档-职务ID不能为空",false);
Assert.isNull(queryPositionDetailReq.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-查询职务是否存档-主体生命周期不能为空",false);
      position = mPositionService.queryPositionDetail(queryPositionDetailReq);



if((listInductionRecord_13!= null&&  listInductionRecord_13 !=null && listInductionRecord_13.size()==0&&listInductionRecord_13!= null&&  listInductionRecord_13 !=null && listInductionRecord_13.size()==0&&position != null )) {
        //if((查询部门职务关系ID下是否还有就职记录.就职记录列表数据集条数 等于 0 and 查询空间下该职务是否已存档.出参 值不等于空 ))  2147

boolean bOOLEAN_8 ;
    DeptPositionRelationship deptPositionRelationship=new DeptPositionRelationship();
  deptPositionRelationship.setSubjectLifeCycle("ARCHIVING");//sourceId:55595_1_2148
deptPositionRelationship.setIsArchive("TRUE");//sourceId:55596_1_2148
if(circulationCollectionsRes!=null){
      deptPositionRelationship.setOrgPositionRelationshipId(circulationCollectionsRes.getDeptPositionRelationshipId());//SimpleFieldAssign//sourceId:55589_1_2148
    }

    /*存档当前部门职务关系ID[1641]   */
    Assert.isNull(deptPositionRelationship.getOrgPositionRelationshipId(),"1111D1-1发布底层框架服务批次	-存档当前部门职务关系ID-组织职务关系ID不能为空",false);
Assert.isNull(deptPositionRelationship.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-存档当前部门职务关系ID-主体生命周期不能为空",false);
Assert.isNull(deptPositionRelationship.getIsArchive(),"1111D1-1发布底层框架服务批次	-存档当前部门职务关系ID-是否存档不能为空",false);
      bOOLEAN_8 = mDeptPositionRelationshipService.updateOrgDeptPosition(deptPositionRelationship);



List<PrivacyDistribution> listPrivacyDistribution_3 =new ArrayList<>();
    QueryTributPowerListReq queryTributPowerListReq=new QueryTributPowerListReq();
  queryTributPowerListReq.setTypeCode("DEPARTMENT_POSITION");//sourceId:55615_1_2149
queryTributPowerListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:55617_1_2149
if(circulationCollectionsRes!=null){
      queryTributPowerListReq.setAllocationObjectId(circulationCollectionsRes.getDeptPositionRelationshipId());//SimpleFieldAssign//sourceId:55616_1_2149
    }

    /*查询存档部门职务关系ID的分配权限列表[497]   */
    Assert.isNull(queryTributPowerListReq.getTypeCode(),"1111D1-1发布底层框架服务批次	-查询存档部门职务关系ID的分配权限列表-分配对象类型编码不能为空",false);
Assert.isNull(queryTributPowerListReq.getAllocationObjectId(),"1111D1-1发布底层框架服务批次	-查询存档部门职务关系ID的分配权限列表-分配对象ID不能为空",false);
Assert.isNull(queryTributPowerListReq.getSubjectLifeCycle(),"1111D1-1发布底层框架服务批次	-查询存档部门职务关系ID的分配权限列表-主体生命周期不能为空",false);
      listPrivacyDistribution_3 = mPrivacyDistributionService.queryTributPowerList(queryTributPowerListReq);



boolean bOOLEAN_9 ;
    if(listPrivacyDistribution_3 !=null&& listPrivacyDistribution_3.size()>0 ){
          List<PrivacyDistribution> listPrivacyDistribution_5=new ArrayList<>();
  listPrivacyDistribution_5 = //objList-to-objLists
        listPrivacyDistribution_3.stream().map(item -> {
      PrivacyDistribution elm = new PrivacyDistribution();
      elm.setPrivacyDistributionId(item.getPrivacyDistributionId());//SimpleFieldAssign//sourceId:30363_2_2150
elm.setSubjectLifeCycle("ARCHIVING");//sourceId:30364_2_2150
elm.setIsArchive("TRUE");//sourceId:30365_2_2150
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:55614_1_2150

    /*存档部门职务关系ID的分配权限[1554]   */

      bOOLEAN_9 = mPrivacyDistributionService.batchUpdateTributPower(listPrivacyDistribution_5);



           }
      }
//virtualUsage M-循环结束（特殊方法）  2146
      //ModelCode: circulationEnd
        }

if((queryItemMatchResultToAnswerDetailComRespDto!= null&&  queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() !=null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG"))) {
        //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 无组织架构)  1526

boolean bOOLEAN_10 ;
    if(listInductionRecord !=null&& listInductionRecord.size()>0 ){
          List<Staffing> listStaffing=new ArrayList<>();
  listStaffing = //objList-to-objLists
        listInductionRecord.stream().map(item -> {
      Staffing elm = new Staffing();
      elm.setStaffingId(item.getStaffingId());//SimpleFieldAssign//sourceId:23684_2_1527
elm.setInductionState("TRUE");//sourceId:23687_2_1527
elm.setTempLock("FALSE");//sourceId:23688_2_1527
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48399_1_1527

    /*本次新增就职记录更新编制[931]   */

      bOOLEAN_10 = mStaffingService.batchUpdateStaffing(listStaffing);



           }
//ModelCode: circulationCollections
        for (InductionRecord circulationCollectionsRes_2: listInductionRecord){

Staffing staffing = null;
    QueryStaffingDetailReq queryStaffingDetailReq=new QueryStaffingDetailReq();
  if(circulationCollectionsRes_2!=null){
      queryStaffingDetailReq.setStaffingId(circulationCollectionsRes_2.getStaffingId());//SimpleFieldAssign//sourceId:53983_1_2064
    }

    /*查询发牌编制的编制账户ID[191]   */
    Assert.isNull(queryStaffingDetailReq.getStaffingId(),"1111D1-1发布底层框架服务批次	-查询发牌编制的编制账户ID-编制ID不能为空",false);
      staffing = mStaffingService.queryStaffingDetail(queryStaffingDetailReq);



//ModelCode: getDataCount
        AddCalculationAddAndSubRespDto getDataCountRes = null;
    if(staffing !=null){
          AddCalculationAddAndSubReqDto getDataCountReq=new AddCalculationAddAndSubReqDto();
  if(staffing!=null){
      getDataCountReq.setStaffingId(staffing.getStaffingAccountId());//SimpleFieldAssign//sourceId:54074_1_2065
    }

    /*M计算发牌编制账户在职加减数量1（特殊方法）[1746]  入参一个数据集，返回数据集条数 */
    Assert.isNull(getDataCountReq.getStaffingId(),"1111D1-1发布底层框架服务批次	-M计算发牌编制账户在职加减数量1（特殊方法）-编制ID不能为空",false);
      getDataCountRes = nbBatch.addCalculationAddAndSub(getDataCountReq);



           }
boolean bOOLEAN_11 ;
    if(staffing !=null){
          StaffingAccount staffingAccount=new StaffingAccount();
  if(staffing!=null){
      staffingAccount.setStaffingAccountId(staffing.getStaffingAccountId());//SimpleFieldAssign//sourceId:54034_1_2066
    }
if(getDataCountRes!=null){
      staffingAccount.setActualStaffingNumber(getDataCountRes.getStaffingNum());//SimpleFieldAssign//sourceId:54035_1_2066
staffingAccount.setVacantStaffingNumber(getDataCountRes.getStaffingNum());//SimpleFieldAssign//sourceId:54036_1_2066
    }

    /*1-3-14加减更新发牌编制账户的在职子账户加减数量1[1780]   */
    Assert.isNull(staffingAccount.getStaffingAccountId(),"1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的在职子账户加减数量1-编制账户ID不能为空",false);
Assert.isNull(staffingAccount.getActualStaffingNumber(),"1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的在职子账户加减数量1-冗余编制在职数量不能为空",false);
Assert.isNull(staffingAccount.getVacantStaffingNumber(),"1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的在职子账户加减数量1-空缺编制数量不能为空",false);
      bOOLEAN_11 = mStaffingAccountService.updateStaffOnAcntNum(staffingAccount);



           }
//ModelCode: circulationEnd
        }

boolean bOOLEAN_12 ;
    if(listInductionRecord_8 !=null&& listInductionRecord_8.size()>0 ){
          List<Staffing> listStaffing_1=new ArrayList<>();
  listStaffing_1 = //objList-to-objLists
        listInductionRecord_8.stream().map(item -> {
      Staffing elm = new Staffing();
      elm.setStaffingId(item.getStaffingId());//SimpleFieldAssign//sourceId:23689_2_1528
elm.setInductionState("FALSE");//sourceId:23690_2_1528
elm.setTempLock("FALSE");//sourceId:23691_2_1528
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48411_1_1528

    /*批量本次存档就职记录释放及解锁编制ID列表[931]   */

      bOOLEAN_12 = mStaffingService.batchUpdateStaffing(listStaffing_1);



           }
//ModelCode: circulationCollections
        for (InductionRecord circulationCollectionsRes_4: listInductionRecord_8){

Staffing staffing_2 = null;
    QueryStaffingDetailReq queryStaffingDetailReq_1=new QueryStaffingDetailReq();
  if(circulationCollectionsRes_4!=null){
      queryStaffingDetailReq_1.setStaffingId(circulationCollectionsRes_4.getStaffingId());//SimpleFieldAssign//sourceId:54071_1_2069
    }

    /*查询存档编制详情[191]   */

      staffing_2 = mStaffingService.queryStaffingDetail(queryStaffingDetailReq_1);



//ModelCode: getDataCount
        AddCalculationAddAndSubRespDto getDataCountRes_2 = null;
    if(staffing_2 !=null){
          AddCalculationAddAndSubReqDto getDataCountReq_1=new AddCalculationAddAndSubReqDto();
  if(staffing_2!=null){
      getDataCountReq_1.setStaffingId(staffing_2.getStaffingAccountId());//SimpleFieldAssign//sourceId:54020_1_2070
    }

    /*M计算存档数值（特殊方法）11[1746]  入参一个数据集，返回数据集条数 */
    Assert.isNull(getDataCountReq_1.getStaffingId(),"1111D1-1发布底层框架服务批次	-M计算存档数值（特殊方法）11-编制ID不能为空",false);
      getDataCountRes_2 = nbBatch.addCalculationAddAndSub(getDataCountReq_1);



           }
boolean bOOLEAN_13 ;
    if(staffing_2 !=null){
          StaffingAccount staffingAccount_1=new StaffingAccount();
  if(staffing_2!=null){
      staffingAccount_1.setStaffingAccountId(staffing_2.getStaffingAccountId());//SimpleFieldAssign//sourceId:54093_1_2071
    }
if(getDataCountRes_2!=null){
      staffingAccount_1.setActualStaffingNumber(getDataCountRes_2.getStaffingNum());//SimpleFieldAssign//sourceId:54094_1_2071
    }
//if(getDataCountRes!=null){
//      staffingAccount_1.setVacantStaffingNumber(getDataCountRes.getStaffingNum());//SimpleFieldAssign//sourceId:54095_1_2071
//    }

    /*1-3-14加减更新发牌编制账户的空缺子账户加减数量1[1781]   */
    Assert.isNull(staffingAccount_1.getStaffingAccountId(),"1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的空缺子账户加减数量1-编制账户ID不能为空",false);
Assert.isNull(staffingAccount_1.getActualStaffingNumber(),"1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的空缺子账户加减数量1-冗余编制在职数量不能为空",false);
Assert.isNull(staffingAccount_1.getVacantStaffingNumber(),"1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的空缺子账户加减数量1-空缺编制数量不能为空",false);
      bOOLEAN_13 = mStaffingAccountService.updateStaffOffAcntNum(staffingAccount_1);



           }
//ModelCode: circulationEnd
        }

boolean bOOLEAN_14 ;
    if(listInductionRecord_2 !=null&& listInductionRecord_2.size()>0 ){
          List<DeptPositionRelationship> listDeptPositionRelationship=new ArrayList<>();
  listDeptPositionRelationship = //objList-to-objLists
        listInductionRecord_2.stream().map(item -> {
      DeptPositionRelationship elm = new DeptPositionRelationship();
      elm.setPositionId(item.getPositionId());//SimpleFieldAssign//sourceId:24507_2_1581
elm.setOrgEntityId(item.getEntityId());//SimpleFieldAssign//sourceId:24509_2_1581
elm.setOrgTypeCode("ORGANIZATION");//sourceId:24508_2_1581
elm.setOrganizationId(item.getOrganizationId());//SimpleFieldAssign//sourceId:24510_2_1581
elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:24513_2_1581
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:49162_1_1581

    /*批量新增组织职务关系ID[1497]   */

      bOOLEAN_14 = mDeptPositionRelationshipService.batchAddDeptPosition(listDeptPositionRelationship);



           }
boolean bOOLEAN_15 ;
    if(listInductionRecord_4 !=null&& listInductionRecord_4.size()>0 ){
          List<DeptPositionRelationship> listDeptPositionRelationship_1=new ArrayList<>();
  listDeptPositionRelationship_1 = //objList-to-objLists
        listInductionRecord_4.stream().map(item -> {
      DeptPositionRelationship elm = new DeptPositionRelationship();
      elm.setPositionId(item.getPositionId());//SimpleFieldAssign//sourceId:24519_2_1582
elm.setOrgEntityId(item.getEntityId());//SimpleFieldAssign//sourceId:24521_2_1582
elm.setOrgTypeCode("DEPARTMENT");//sourceId:24520_2_1582
elm.setOrganizationId(item.getOrganizationId());//SimpleFieldAssign//sourceId:24522_2_1582
elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:24525_2_1582
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:49164_1_1582

    /*批量新增部门职务关系ID[1497]   */

      bOOLEAN_15 = mDeptPositionRelationshipService.batchAddDeptPosition(listDeptPositionRelationship_1);



           }
boolean bOOLEAN_16 ;
    if(batch !=null){
          Organization organization_1=new Organization();
  organization_1.setUsingLockStatus("UNLOCK");//sourceId:48451_1_1529
organization_1.setReasonOfUsingLock("---");//NULL//sourceId:172615_1_1529
if(batch!=null){
      organization_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48447_1_1529
    }

    /*组织架构使用自动锁定-对外恢复正常使用[197]   */
    Assert.isNull(organization_1.getOrganizationId(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-组织ID不能为空",false);
Assert.isNull(organization_1.getUsingLockStatus(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定状态不能为空",false);
Assert.isNull(organization_1.getReasonOfUsingLock(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定原因不能为空",false);
Assert.isNull(organization_1.getCurrentManageObjectType(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-当前管理对象类型不能为空",false);
      bOOLEAN_16 = mOrganizationService.updateOrg(organization_1);



           }
//ModelCode: batchClearUserInfoFromRedis
        BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes = null;
    if(listInductionRecord_8 !=null&& listInductionRecord_8.size()>0 ){
          BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq=new BatchClearUserInfoFromRedisReqDto();
  batchClearUserInfoFromRedisReq.setBeginMemberList(listInductionRecord_8.stream().map(item->item.getOriginalRoleMemberId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51052_1_1697

    /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */

      batchClearUserInfoFromRedisRes = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq);



           }
//processBranchName:正常结束 ,processBranchId:1530

      }
else{
       //else  1531

boolean bOOLEAN_17 ;
    if(batch !=null){
          Organization organization_2=new Organization();
  organization_2.setUsingLockStatus("UNLOCK");//sourceId:48451_1_1532
organization_2.setReasonOfUsingLock("---");//NULL//sourceId:172615_1_1532
if(batch!=null){
      organization_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48447_1_1532
    }

    /*组织架构使用自动锁定-对外恢复正常使用[197]   */
    Assert.isNull(organization_2.getOrganizationId(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-组织ID不能为空",false);
Assert.isNull(organization_2.getUsingLockStatus(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定状态不能为空",false);
Assert.isNull(organization_2.getReasonOfUsingLock(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定原因不能为空",false);
Assert.isNull(organization_2.getCurrentManageObjectType(),"1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-当前管理对象类型不能为空",false);
      bOOLEAN_17 = mOrganizationService.updateOrg(organization_2);



           }
//ModelCode: batchClearUserInfoFromRedis
        BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes_1 = null;
    if(listInductionRecord_8 !=null&& listInductionRecord_8.size()>0 ){
          BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq_1=new BatchClearUserInfoFromRedisReqDto();
  batchClearUserInfoFromRedisReq_1.setBeginMemberList(listInductionRecord_8.stream().map(item->item.getOriginalRoleMemberId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51052_1_1698

    /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */

      batchClearUserInfoFromRedisRes_1 = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq_1);



           }
//processBranchName:正常结束 ,processBranchId:1533

    }
ReleaseBaseBatchRespDto retData = new ReleaseBaseBatchRespDto();





return retData;
  }
/**
   * 1111D1-1删除底层框架服务批次[936]
   * gen by moon at 10/2/2022, 7:51:21 AM
   */
  @Trace(operationName = "1111D1-1删除底层框架服务批次")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteBaseBatchRespDto deleteBaseBatch(DeleteBaseBatchReqDto reqDto){


      //virtualUsage 通过批次ID，查出批次ID对应的用途类型编码、归属对象ID  1539
      Batch batch = null;
    QueryBaseBatchDetailReq queryBaseBatchDetailReq=new QueryBaseBatchDetailReq();
  if(reqDto!=null){
      queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:19760_1_1539
    }

    /*通过批次ID，查出批次ID对应的用途类型编码、归属对象ID[44]   */
    Assert.isNull(queryBaseBatchDetailReq.getSpaceId(),"1111D1-1删除底层框架服务批次-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于空间ID不能为空",false);
Assert.isNull(queryBaseBatchDetailReq.getAppId(),"1111D1-1删除底层框架服务批次-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于联盟应用ID不能为空",false);
      batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);



//virtualUsage 1-1-01删除底层框架服务批次	  1540
      boolean bOOLEAN ;
    String string=new String();
  if(reqDto!=null){
      string=reqDto.getBatchId();;//SimpleFieldAssign//sourceId:23734_1_1540
    }

    /*1-1-01删除底层框架服务批次	[43]   */
    Assert.isNull(string,"1111D1-1删除底层框架服务批次-1-1-01删除底层框架服务批次	-批次ID不能为空",false);
      bOOLEAN = mBatchService.deleteBaseBatch(string);



//virtualUsage D2-3查询配置项匹配结果转答案(公共)  5667
      QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
    QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto=new QueryItemMatchResultToAnswerDetailComReqDto();
  queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105308_1_5667
queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:105309_1_5667
queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105310_1_5667

    /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(),"1111D1-1删除底层框架服务批次-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(),"1111D1-1删除底层框架服务批次-D2-3查询配置项匹配结果转答案(公共)-答案归属对象类型不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"1111D1-1删除底层框架服务批次-D2-3查询配置项匹配结果转答案(公共)-答案归属对象ID不能为空",false);
      queryItemMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData();



//virtualUsage 修改组织临时冻结  1543
      boolean bOOLEAN_1 ;
    if(batch !=null){
          Organization organization=new Organization();
  organization.setManageLockStatus("TRUE");//sourceId:48570_1_1543
//organization.setReasonOfManageLock();//AUTOMATIC_STAY  TODO ruizhe dong//sourceId:48571_1_1543
organization.setUsingLockStatus("TRUE");//sourceId:48572_1_1543
if(batch!=null){
      organization.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48569_1_1543
    }

    /*修改组织临时冻结[197]   */

      bOOLEAN_1 = mOrganizationService.updateOrg(organization);



           }
//virtualUsage 查询本次新增的就职记录列表  1544
      List<InductionRecord> listInductionRecord =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq=new QueryInductionRecordListReq();
  queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:48688_1_1544
if(batch!=null){
      queryInductionRecordListReq.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48687_1_1544
    }

    /*查询本次新增的就职记录列表[166]   */
    Assert.isNull(queryInductionRecordListReq.getOrganizationId(),"1111D1-1删除底层框架服务批次-查询本次新增的就职记录列表-组织ID不能为空",false);
Assert.isNull(queryInductionRecordListReq.getUpdateStatus(),"1111D1-1删除底层框架服务批次-查询本次新增的就职记录列表-批次下更新状态不能为空",false);
      listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);



           }
//virtualUsage 查询本次修订的就职记录列表  1545
      List<InductionRecord> listInductionRecord_2 =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq_1=new QueryInductionRecordListReq();
  queryInductionRecordListReq_1.setUpdateStatus("REVISION");//sourceId:48690_1_1545
if(batch!=null){
      queryInductionRecordListReq_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48689_1_1545
    }

    /*查询本次修订的就职记录列表[166]   */

      listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);



           }
//virtualUsage 1-1-02批量查询变更字段列表ByIds  1564
      List<ChangeColumn> listChangeColumn =new ArrayList<>();
    if(listInductionRecord_2 !=null&& listInductionRecord_2.size()>0 ){
          BatchQueryBaseChangeColListByIdsReq batchQueryBaseChangeColListByIdsReq=new BatchQueryBaseChangeColListByIdsReq();
  batchQueryBaseChangeColListByIdsReq.setTableTypeCode("CUSTOM_CONVENTION");//sourceId:48788_1_1564
batchQueryBaseChangeColListByIdsReq.setChangeEntityId(listInductionRecord_2.stream().map(item->item.getInductionRecordId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:48789_1_1564
batchQueryBaseChangeColListByIdsReq.setIsInproperties("TRUE");//sourceId:48797_1_1564
batchQueryBaseChangeColListByIdsReq.setSubjectLifeCycle("EDITING");//sourceId:48792_1_1564
batchQueryBaseChangeColListByIdsReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:48798_1_1564
batchQueryBaseChangeColListByIdsReq.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:48799_1_1564

    /*1-1-02批量查询变更字段列表ByIds[310]   */
    Assert.isNull(batchQueryBaseChangeColListByIdsReq.getTableTypeCode(),"1111D1-1删除底层框架服务批次-1-1-02批量查询变更字段列表ByIds-内容表类型编码不能为空",false);
      listChangeColumn = mChangeColumnService.batchQueryBaseChangeColListByIds(batchQueryBaseChangeColListByIdsReq);



           }
//virtualUsage 1-1-02批量删除底层框架服务变更字段  1565
      boolean bOOLEAN_2 ;
    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
          List<String> listString=new ArrayList<>();
  listString = listChangeColumn.stream().map(item->item.getChangeColumnId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:48521_1_1565

    /*1-1-02批量删除底层框架服务变更字段[7]   */

      bOOLEAN_2 = mChangeColumnService.batchDeleteBaseChangeColumn(listString);



           }
//virtualUsage 查询本次存档的就职记录列表  1546
      List<InductionRecord> listInductionRecord_4 =new ArrayList<>();
    if(batch !=null){
          QueryInductionRecordListReq queryInductionRecordListReq_2=new QueryInductionRecordListReq();
  queryInductionRecordListReq_2.setUpdateStatus("ARCHIVE");//sourceId:48692_1_1546
if(batch!=null){
      queryInductionRecordListReq_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48691_1_1546
    }

    /*查询本次存档的就职记录列表[166]   */

      listInductionRecord_4 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2);



           }
//virtualUsage 1-3-13批量删除就职记录  5484
      boolean bOOLEAN_3 ;
    if(listInductionRecord !=null&& listInductionRecord.size()>0 ){
          List<String> listString_1=new ArrayList<>();
  listString_1 = listInductionRecord.stream().map(item->item.getInductionRecordId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:102891_1_5484

    /*1-3-13批量删除就职记录[1685]   */

      bOOLEAN_3 = mInductionRecordService.batchDeleteInductionRecord(listString_1);



           }
//virtualUsage 修改本次修订就职记录  1548
      boolean bOOLEAN_4 ;
    if(listInductionRecord_2 !=null&& listInductionRecord_2.size()>0 ){
          List<InductionRecord> listInductionRecord_6=new ArrayList<>();
  listInductionRecord_6 = //objList-to-objLists
        listInductionRecord_2.stream().map(item -> {
      InductionRecord elm = new InductionRecord();
      elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23964_2_1548
elm.setIsUpdate("FALSE");//sourceId:23972_2_1548
elm.setUpdateStatus("UNCHANGED");//sourceId:23973_2_1548
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48693_1_1548

    /*修改本次修订就职记录[1647]   */

      bOOLEAN_4 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_6);



           }
//virtualUsage 修改本次存档就职记录  1549
      boolean bOOLEAN_5 ;
    if(listInductionRecord_4 !=null&& listInductionRecord_4.size()>0 ){
          List<InductionRecord> listInductionRecord_7=new ArrayList<>();
  listInductionRecord_7 = //objList-to-objLists
        listInductionRecord_4.stream().map(item -> {
      InductionRecord elm = new InductionRecord();
      elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23986_2_1549
elm.setArchivngType("NOT_ARCHIVE");//sourceId:23992_2_1549
elm.setIsUpdate("FALSE");//sourceId:23994_2_1549
elm.setUpdateStatus("UNCHANGED");//sourceId:23995_2_1549
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48697_1_1549

    /*修改本次存档就职记录[1647]   */

      bOOLEAN_5 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_7);



           }
//virtualUsage D1-1修改检查项状态(公共)  8671
      UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
    if(batch !=null){
          UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto=new UpdateCheckItemStatComReqDto();
  updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144897_1_8671
updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144898_1_8671
updateCheckItemStatComReqDto.setIsComplete("TRUE");//sourceId:144896_1_8671
if(batch!=null){
      updateCheckItemStatComReqDto.setEntityId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:144899_1_8671
    }

    /*D1-1修改检查项状态(公共)[947]   */
    Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(),"1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-检查项标识不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(),"1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-内容对象类型编码不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getEntityId(),"1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-内容对象实例ID不能为空",false);
Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(),"1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-是否已完成不能为空",false);
      updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);



           }
if((queryItemMatchResultToAnswerDetailComRespDto!= null&&  queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() !=null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("PLAN_STAFFING"))) {
        //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 计划编制型)  5367

boolean bOOLEAN_6 ;
    if(listInductionRecord !=null&& listInductionRecord.size()>0 ){
          List<Staffing> listStaffing=new ArrayList<>();
  listStaffing = //objList-to-objLists
        listInductionRecord.stream().map(item -> {
      Staffing elm = new Staffing();
      elm.setStaffingId(item.getStaffingId());//SimpleFieldAssign//sourceId:23996_2_5368
elm.setInductionState("FALSE");//sourceId:23997_2_5368
elm.setTempLock("FALSE");//sourceId:23998_2_5368
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:48698_1_5368

    /*本次新增就职记录更新编制[931]   */

      bOOLEAN_6 = mStaffingService.batchUpdateStaffing(listStaffing);



           }
boolean bOOLEAN_7 ;
    if(batch !=null){
          Organization organization_1=new Organization();
  organization_1.setManageLockStatus("FALSE");//sourceId:48716_1_5369
organization_1.setUsingLockStatus("FALSE");//sourceId:48718_1_5369
if(batch!=null){
      organization_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48715_1_5369
    }

    /*修改组织取消临时冻结[197]   */
    Assert.isNull(organization_1.getOrganizationId(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-组织ID不能为空",false);
Assert.isNull(organization_1.getManageLockStatus(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定状态不能为空",false);
Assert.isNull(organization_1.getReasonOfManageLock(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定原因不能为空",false);
Assert.isNull(organization_1.getUsingLockStatus(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-使用锁定状态不能为空",false);
      bOOLEAN_7 = mOrganizationService.updateOrg(organization_1);



           }
//processBranchName:正常结束 ,processBranchId:5370

      }
else{
       //else  1554

boolean bOOLEAN_8 ;
    if(batch !=null){
          Organization organization_2=new Organization();
  organization_2.setManageLockStatus("FALSE");//sourceId:48716_1_1555
organization_2.setUsingLockStatus("FALSE");//sourceId:48718_1_1555
if(batch!=null){
      organization_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48715_1_1555
    }

    /*修改组织取消临时冻结[197]   */
    Assert.isNull(organization_2.getOrganizationId(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-组织ID不能为空",false);
Assert.isNull(organization_2.getManageLockStatus(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定状态不能为空",false);
Assert.isNull(organization_2.getReasonOfManageLock(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定原因不能为空",false);
Assert.isNull(organization_2.getUsingLockStatus(),"1111D1-1删除底层框架服务批次-修改组织取消临时冻结-使用锁定状态不能为空",false);
      bOOLEAN_8 = mOrganizationService.updateOrg(organization_2);



           }
//processBranchName:正常结束 ,processBranchId:1556

    }
DeleteBaseBatchRespDto retData = new DeleteBaseBatchRespDto();



  
  
return retData;
  }
/**
   * D1执行生命周期判断(公共)[7830]
   * gen by moon at 11/10/2023, 3:05:44 PM
   */
  @Trace(operationName = "D1执行生命周期判断(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLifeCycleJudgmentComRespDto implementLifeCycleJudgmentCom(ImplementLifeCycleJudgmentComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getLifecyCycleOperationType() !=null && reqDto.getLifecyCycleOperationType().equals("DELETE"))) {
        //if(D3执行生命周期判断(公共).生命周期操作类型 等于 删除)  52446

if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID")||reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("ARCHIVING"))) {
        //if((D3执行生命周期判断(公共).主体生命周期 等于 当前有效 or D3执行生命周期判断(公共).主体生命周期 等于 历史存档))  52452

//异常结束 52461
      throw new BizException("3P10100267","对不起不可操作！～因为当前状态不对，请手动刷新页面～。",false);
      }
      }
else if((reqDto!= null&&  reqDto.getLifecyCycleOperationType() !=null && reqDto.getLifecyCycleOperationType().equals("ARCHIVE"))){
       //elseif(D3执行生命周期判断(公共).生命周期操作类型 等于 存档)  52447

if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING")||reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("ARCHIVING"))) {
        //if((D3执行生命周期判断(公共).主体生命周期 等于 正在编辑 or D3执行生命周期判断(公共).主体生命周期 等于 历史存档))  52454

//异常结束 52462
      throw new BizException("3P10100267","对不起不可操作！～因为当前状态不对，请手动刷新页面～。",false);
      }
    }
else if((reqDto!= null&&  reqDto.getLifecyCycleOperationType() !=null && reqDto.getLifecyCycleOperationType().equals("UNDO_ARCHIVE"))){
       //elseif(D3执行生命周期判断(公共).生命周期操作类型 等于 撤销存档)  52448

if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID")||reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
        //if((D3执行生命周期判断(公共).主体生命周期 等于 当前有效 or D3执行生命周期判断(公共).主体生命周期 等于 正在编辑))  52460

//异常结束 52463
      throw new BizException("3P10100267","对不起不可操作！～因为当前状态不对，请手动刷新页面～。",false);
      }
    }
else{
       //else  52449

//异常结束 52450
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
ImplementLifeCycleJudgmentComRespDto retData = new ImplementLifeCycleJudgmentComRespDto();





return retData;
  }

    //
}